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

// f32\sfsrv\cl_file.cpp

// 

//

#include "cl_std.h"

static _LIT_SECURITY_POLICY_S1(KFileServerPolicy,KFileServerUidValue,ECapabilityTCB);

EFSRV_EXPORT_C TInt RFile::Adopt(RFs& aFs, TInt aHandle)

/**

Adopts an already open file.

@param aFs     The file server session.

@param aHandle The handle number of the already opened file

@return KErrNone if successful, 

		KErrBadHandle if the sub-session handle is invalid, 

		otherwise one of the other system-wide error codes.

@deprecated

*/

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFileAdopt, MODULEUID, aFs.Handle(), aHandle);

	// duplicate the sub-session handle; don't panic if it's invalid.

	RFile file;

	TInt r = file.CreateSubSession(aFs, EFsFileDuplicate, TIpcArgs(aHandle, EFalse));

	if (r == KErrArgument)

		{

		TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptReturn, MODULEUID, KErrBadHandle);

		return KErrBadHandle;

		}

	else if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptReturn, MODULEUID, r);

		return r;

		}

	// adopt the duplicated handle

	r = CreateAutoCloseSubSession(aFs, EFsFileAdopt, TIpcArgs(file.SubSessionHandle(), KFileAdopt32));

	TRACERET3(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptReturn, MODULEUID, r, Session().Handle(), SubSessionHandle());

	return r;

	}

EFSRV_EXPORT_C TInt RFile::AdoptFromServer(TInt aFsHandle, TInt aFileHandle)

/**

Allows a client to adopt an already open file from a server.

Assumes that the server's RFs and RFile handles have been sent to the 

client using TransferToClient().

This RFile will own it's RFs session so that when the sub-session (RFile) 

is closed so will the RFs session.

@param aFsHandle The file server session (RFs) handle

@param aFileHandle The file (RFile) handle of the already opened file

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

        error codes.

*/

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromServer, MODULEUID, aFsHandle, aFileHandle);

	RFs fs;

	TInt r = fs.SetReturnedHandle(aFsHandle, KFileServerPolicy);

	if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromServerReturn, MODULEUID, r);

		return r;

		}

	r = CreateAutoCloseSubSession(fs, EFsFileAdopt, TIpcArgs(aFileHandle, KFileAdopt32));

	TRACERET3(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromServerReturn, MODULEUID, r, Session().Handle(), SubSessionHandle());

	return r;

	}

EFSRV_EXPORT_C TInt RFile::AdoptFromClient(const RMessage2& aMsg, TInt aFsHandleIndex, TInt aFileHandleIndex)

/**

Allows a server to adopt an already open file from a client.

The client's RFs and RFile handles are contained in message slots within aMsg.

Assumes that the client's RFs and RFile handles have been sent to the server

using TransferToServer().

This RFile will own it's RFs session so that when the sub-session (RFile) 

is closed so will the RFs session.

@param	aMsg		The message received from the client

@param	aFsHandleIndex	The index that identifies the message slot 

					of a file server session (RFs) handle

@param aFileHandleIndex The index that identifies the message slot 

					of the sub-session (RFile) handle of the already opened file

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

        error codes.

*/

	{

	TInt fileHandle = NULL;

	TInt r = KErrNone;

	if (aFileHandleIndex == 0)

		fileHandle = aMsg.Int0();

	else if (aFileHandleIndex == 1)

   		fileHandle = aMsg.Int1();

	else if (aFileHandleIndex == 2)

		fileHandle = aMsg.Int2();

	else if (aFileHandleIndex == 3)

		fileHandle = aMsg.Int3();

	else

		r = KErrArgument;

#ifdef SYMBIAN_FTRACE_ENABLE

	TInt handle = NULL;

	if (aFsHandleIndex == 0)

		handle = aMsg.Int0();

	else if (aFsHandleIndex == 1)

   		handle = aMsg.Int1();

	else if (aFsHandleIndex == 2)

		handle = aMsg.Int2();

	else if (aFsHandleIndex == 3)

		handle = aMsg.Int3();

	TRACE4(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromClient, MODULEUID, handle, fileHandle, aFsHandleIndex, aFileHandleIndex);

#endif

	if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromClientReturn, MODULEUID, r);

		return r;

		}

	// Duplicates the file server (RFs) session handle identified by an 

	// existing handle contained in the message slot at index aFsHandleIndex

	RFs fs;

	r = fs.Open(aMsg, aFsHandleIndex, KFileServerPolicy);

	if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromClientReturn, MODULEUID, r);

		return r;

		}

	r = CreateAutoCloseSubSession(fs, EFsFileAdopt, TIpcArgs(fileHandle, KFileAdopt32));

	TRACERET3(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromClientReturn, MODULEUID, r, Session().Handle(), SubSessionHandle());

	return r;

	}

EFSRV_EXPORT_C TInt RFile::AdoptFromCreator(TInt aFsHandleIndex, TInt aFileHandleIndex)

/**

Allows a server to adopt an already open file from a client process.

The client's file-server (RFs) and file (RFile) handles are contained in 

this process's environment data slots.

Assumes that the client's RFs and RFile handles have been sent to the server process

using TransferToProcess().

This RFile will own it's RFs session so that when the sub-session (RFile) 

is closed so will the RFs session.

@param	aFsHandleIndex	An index that identifies the slot in the process

					environment data that contains the file server session (RFs) handle

@param	aFileHandleIndex	An index that identifies the slot in the process

					environment data that contains the sub-session (RFile) handle 

					of the already opened file

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

        error codes.

*/

	{

	TInt fileHandle = NULL;

	TInt r = User::GetTIntParameter(aFileHandleIndex,  fileHandle);

	TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromCreator, MODULEUID, fileHandle, aFsHandleIndex, aFileHandleIndex);

	if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromCreatorReturn, MODULEUID, r);

		return r;

		}

	// Duplicates the file server (RFs) session handle identified by an 

	// existing handle contained in the environment slot at index aFsHandleIndex

	RFs fs;

	r = fs.Open(aFsHandleIndex, KFileServerPolicy);

	if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromCreatorReturn, MODULEUID, r);

		return r;

		}

	r = CreateAutoCloseSubSession(fs, EFsFileAdopt, TIpcArgs(fileHandle, KFileAdopt32));

	TRACERET3(UTF::EBorder, UTraceModuleEfsrv::EFileAdoptFromCreatorReturn, MODULEUID, r, Session().Handle(), SubSessionHandle());

	return r;

	}

/**

Make a duplicate of the passed file handle in the same thread.

By default, any thread in the process can use the duplicated handle to access the 

file. However, specifying EOwnerThread as the second parameter to this function, 

means that only the creating thread can use the handle.

@param	aFile	The file handle to duplicate

@param	aType	An enumeration whose enumerators define the ownership of this 

				handle. If not explicitly specified, EOwnerProcess is taken

				as default.

@return	one of the other system-wide error codes.

*/

EFSRV_EXPORT_C TInt RFile::Duplicate(const RFile& aFile, TOwnerType aType)

	{

	TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFileDuplicate, MODULEUID, aFile.Session().Handle(), aFile.SubSessionHandle(), aType);

	RFs fs;

	fs.SetHandle(aFile.Session().Handle());

	// Need to make a duplicate of the session handle in the current thread, 

	// otherwise closing one session will close both sub-sessions.

	TInt r = fs.Duplicate(RThread(), aType);

	if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileDuplicateReturn, MODULEUID, r);

		return r;

		}

	// duplicate the sub-session handle

	TInt dupSubSessionHandle;

	r = aFile.DuplicateHandle(dupSubSessionHandle);

	if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileDuplicateReturn, MODULEUID, r);

		return r;

		}

	// adopt the duplicated sub-session handle

	r = CreateAutoCloseSubSession(fs, EFsFileAdopt, TIpcArgs(dupSubSessionHandle, KFileDuplicate));

	TRACERET3(UTF::EBorder, UTraceModuleEfsrv::EFileDuplicateReturn, MODULEUID, r, Session().Handle(), SubSessionHandle());

	return r;

	}

// Makes a duplicate of this file (RFile) handle in the current thread and 

// returns it in aSubSessionHandle. 

// The duplicate file handle will effectively be in limbo (although still 

// owned by the session) until :

// (1) the session handle is duplicated into another process - 

//     this happens in one of : TransferToClient(), TransferToProcess() or 

//     AdoptFromClient() and

// (2) the sub-session handle is transferred to the other process - using AdoptXXX()

// 

TInt RFile::DuplicateHandle(TInt& aSubSessionHandle) const

	{

	RFs fs;

	fs.SetHandle(Session().Handle());

	RFile file;

	// duplicate the sub-session handle; panic if it's invalid.

	TInt r = file.CreateSubSession(fs, EFsFileDuplicate, TIpcArgs(SubSessionHandle(), ETrue));

	// return the duplicated handle

	// Note that this handle needs to be adopted before it can be used

	aSubSessionHandle = file.SubSessionHandle();

	return r;

	}

/**

Transfers an already open file to a server.

Before this function can be called, the file server session which owns this file handle

must first be marked as shareable by calling RFs::ShareProtected().

This function packages handle details for this file into 2 arguments of a TIpcArgs object.

When these arguments are sent in an IPC message, the server which receives them may 

call AdoptFromClient() to open a new RFile object which refers to the same file as this.

@param	aIpcArgs	The IPC message arguments.

@param	aFsHandleIndex	An index that identifies an argument in aIpcArgs where the

					file server session handle will be stored.

					This argument must not be used for anything else otherwise the 

					results will be unpredictable.

@param	aFileHandleIndex	An index that identifies an argument in aIpcArgs where the

					file handle will be stored.

					This argument must not be used for anything else otherwise the 

					results will be unpredictable.

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

		error codes.

*/

EFSRV_EXPORT_C TInt RFile::TransferToServer(TIpcArgs& aIpcArgs, TInt aFsHandleIndex, TInt aFileHandleIndex) const

	{

	TRACE4(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToServer, MODULEUID, Session().Handle(), SubSessionHandle(), aFsHandleIndex, aFileHandleIndex);

	if ((aFsHandleIndex < 0) || (aFsHandleIndex > (KMaxMessageArguments-2)))

		{

		TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToServerReturn, MODULEUID,  (TUint) KErrArgument);

		return KErrArgument;

		}

	TInt dupSubSessionHandle;

	TInt r = DuplicateHandle(dupSubSessionHandle);

	if (r == KErrNone)

		{

		aIpcArgs.Set(aFsHandleIndex, Session());

		aIpcArgs.Set(aFileHandleIndex, dupSubSessionHandle);

		}

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToServerReturn, MODULEUID, r);

	return r;

	}

/**

Transfers an already open file from a server to a client.

Before this function can be called, the file server session which owns this file handle

must first be marked as shareable by calling RFs::ShareProtected().

The file (RFile) handle is written to the client's address space to the package 

buffer in the message address slot in aMsg identified by aFileHandleIndex.

If no error occurs, then the message is completed with the file-server (RFs) 

session handle.

When the message completes, the client may call AdoptFromServer() to open 

a new RFile object which refers to the same file as this.

Note that if an error occurs then the message is not completed.

@param	aMsg		A message received from the client

@param	aFileHandleIndex	Identifies the message slot that contains a package 

					buffer pointing to an address in the client's address space 

					to receive the file (RFile) handle

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

        error codes.

*/

EFSRV_EXPORT_C TInt RFile::TransferToClient(const RMessage2& aMsg, TInt aFileHandleIndex) const

	{

	TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToClient, MODULEUID, Session().Handle(), SubSessionHandle(), aFileHandleIndex);

	if (TUint(aFileHandleIndex) >= TUint(KMaxMessageArguments))

		{

		TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToClientReturn, MODULEUID,  (TUint) KErrArgument);

		return KErrArgument;

		}

	TInt dupSubSessionHandle;

	TInt r = DuplicateHandle(dupSubSessionHandle);

	if (r == KErrNone)

		r = aMsg.Write(aFileHandleIndex, TPckgC<TInt>(dupSubSessionHandle));

	if (r != KErrNone)

		{

		TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToClientReturn, MODULEUID, r);

		return r;

		}

	aMsg.Complete(Session());

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToClientReturn, MODULEUID, r);

	return r;

	}

/**

Transfers an already open file to another process.

Before this function can be called, the file server session which owns this file handle

must first be marked as shareable by calling RFs::ShareProtected().

This function packages handle details for this file into 2 arguments in another

process's  environment data slots.

When the other process runs, it may call AdoptFromCreator() to open a new RFile 

object which refers to the same file as this.

@param	aProcess	A handle to another process.

@param	aFsHandleIndex	An index that identifies a slot in the process's

					environment data which on exit will contain the file server 

					session (RFs) handle 

					This slot must not be used for anything else otherwise the 

					results will be unpredictable.

@param	aFileHandleIndex	An index that identifies a slot in the process's

					environment data which on exit will contain the file 

					(RFile) handle.

					This slot must not be used for anything else otherwise the 

					results will be unpredictable.

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

        error codes.

*/

// NB slot 0 is reserved for the command line

EFSRV_EXPORT_C TInt RFile::TransferToProcess(RProcess& aProcess, TInt aFsHandleIndex, TInt aFileHandleIndex) const

	{

	TRACE4(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToProcess, MODULEUID, Session().Handle(), SubSessionHandle(), aFsHandleIndex, aFileHandleIndex);

	TInt dupSubSessionHandle;

	TInt r = DuplicateHandle(dupSubSessionHandle);

	if (r == KErrNone)

		r = aProcess.SetParameter(aFsHandleIndex, RHandleBase(Session()));

	if (r == KErrNone)

		r = aProcess.SetParameter(aFileHandleIndex, dupSubSessionHandle);

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFileTransferToProcessReturn, MODULEUID, r);

	return r;

	}

EFSRV_EXPORT_C TInt RFile::Name(TDes& aName) const

/**

Gets the final part of a filename

This is used to retrieve the name and extension of a file that has been 

passed from one process to another using the RFile::AdoptXXX() methods.

@param	aName	On return, contains the name of the file, including the name and 

				extension but excluding the drive letter and path.

@return KErrNone if successful, otherwise one of the other

        system-wide error codes.

*/

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFileName, MODULEUID, Session().Handle(), SubSessionHandle());

	TInt r = SendReceive(EFsFileName, TIpcArgs(&aName));

	TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFileNameReturn, MODULEUID, r, aName);

	return r;

	}

EFSRV_EXPORT_C TInt RFile::FullName(TDes& aName) const

/**

Gets the full filename

This is used to retrieve the full filename, including drive and path,

of a file that has been passed from one process to another using the 

RFile::AdoptXXX() methods.

@param	aName	On return, contains the full name of the file, including drive and path.

@return KErrNone if successful, otherwise one of the other

        system-wide error codes.

*/

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFileFullName, MODULEUID, Session().Handle(), SubSessionHandle());

	TInt r = SendReceive(EFsFileFullName, TIpcArgs(&aName));

	TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFileFullNameReturn, MODULEUID, r, aName);

	return r;

	}

EFSRV_EXPORT_C TInt RFile::Open(RFs& aFs,const TDesC& aName,TUint aMode)

/**

Opens an existing file for reading or writing.

If the file does not already exist, an error is returned.

Notes:

1. To close the file, use Close()

2. Attempting to open a file with the read-only attribute using the EFileWrite

   access mode results in an error.

3. Attempting to open a file which is greater than or equal to 2GByte (2,147,483,648 bytes)

   will fail with KErrTooBig

4. After a file has been opened, the current write position is set to the start

   of the file.

   If necessary, use RFile::Seek() to move to a different position within

   the file.

@param aFs   The file server session.

@param aName The name of the file. Any path components (i.e. drive letter

             or directory), which are not specified, are taken from

             the session path.The file name shall not contain wild cards

             ('?' or '*' characters) and illegal characters like 

             '<', '>', ':', '"', '/', '|' and '\000'. Backslash '\\' character 

             is allowed only as a path delimiter. The filename containing only 

             white space characters (See TChar::IsSpace()) is also illegal.

@param aMode The mode in which the file is opened. See TFileMode.

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

        error codes.

@see TFileMode

@capability Dependent If the path for aName is /Sys and aMode is neither

					  EFileShareReadersOnly nor EFileRead then Tcb capability is required.

@capability Dependent If the path for aName is /Sys and aMode is either

					  EFileShareReadersOnly or EFileRead then Allfiles capability is required.

@capability Dependent If the path for aName begins with /Private and does not match this process'

					  SID then AllFiles capability is required.

@capability Dependent If the path for aName begins with /Resource and aMode is neither

 					  EFileShareReadersOrWriters|EFileRead nor EFileShareReadersOnly 

 					  nor EFileRead then Tcb capability is required.

*/

	{

	TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFileOpen, MODULEUID, aFs.Handle(), aMode, aName);

	aMode &= ~EFileBigFile;

	TInt r = CreateSubSession(aFs,EFsFileOpen,TIpcArgs(&aName,aMode));

	TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFileOpenReturn, MODULEUID, r, SubSessionHandle());

	return r;

	}

EFSRV_EXPORT_C void RFile::Close()

/**

Closes the file.

Any open files are closed when the file server session is closed.

Close() is guaranteed to return, and provides no indication whether

it completed successfully or not. When closing a file you have written to,

you should ensure that data is committed to the file by invoking RFile::Flush()

before closing. If Flush() completes successfully, Close() is essentially a

no-operation.

*/

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFileClose, MODULEUID, Session().Handle(), SubSessionHandle());

#if defined (SYMBIAN_FTRACE_ENABLE) && defined(__DLL__)

	// Need to close the handle to the trace LDD if this is an auto-close subsession

	// as these close their parent session by calling RHandleBase::Close(), i.e. they

	// bypass RFs::Close() which would normally be responsible for closing the LDD

	TInt h = Session().Handle() ^ CObjectIx::ENoClose;

	if ( h != NULL && (!(h & CObjectIx::ENoClose)) ) 

		{

		RFTRACE_CLOSE;

		}

#endif

	CloseSubSession(EFsFileSubClose);

	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFileCloseReturn, MODULEUID);

	}

EFSRV_EXPORT_C TInt RFile::Create(RFs& aFs,const TDesC& aName,TUint aMode)

/**

Creates and opens a new file for writing.

If the file already exists, an error is returned.

If the resulting path does not exist, then the operation cannot proceed and

the function returns an error code.

Notes:

1. To close the file, use Close()

2. It automatically sets the file's archive attribute.

@param aFs   The file server session.

@param aName The name of the file. Any path components (i.e. drive letter

             or directory), which are not specified, are taken from

             the session path. The file name shall not contain wild cards

             ('?' or '*' characters) and illegal characters like 

             '<', '>', ':', '"', '/', '|' and '\000'. Backslash '\\' character 

             is allowed only as a path delimiter. The filename containing only 

             white space characters (See TChar::IsSpace()) is also illegal.

@param aMode The mode in which the file is opened. The access mode is

             automatically set to EFileWrite. See TFileMode.

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

        error codes.

@see TFileMode

@capability Dependent If the path in aName starts with /Sys then capability Tcb is required

@capability Dependent If the path in aName starts with /Resource then capability Tcb is required

@capability Dependent If the path in aName starts with /Private and does not match this process'

					  SID then AllFiles capability is required.

*/

	{

	aMode &= ~EFileBigFile;

	TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFileCreate, MODULEUID, aFs.Handle(), aMode, aName);

	TInt r = CreateSubSession(aFs,EFsFileCreate,TIpcArgs(&aName,aMode));

	TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFileCreateReturn, MODULEUID, r, SubSessionHandle());

	return r;

	}

EFSRV_EXPORT_C TInt RFile::Replace(RFs& aFs,const TDesC& aName,TUint aMode)

/**

Opens a file for writing, replacing the content of any existing file of the

same name if it exists, or creating a new file if it does not exist.

If the resulting path exists, then:

- the length of an existing file with the same filename is re-set to zero 

- a new file is created, if no existing file with the same filename can be found.

If the resulting path does not exist, then the operation cannot proceed and

the function returns an error code.

Notes:

- To close the file, use Close(), defined in the base class RFsBase.

- It automatically sets the file's archive attribute.

@param aFs   The file server session.

@param aName The name of the file. Any path components (i.e. drive letter

             or directory), which are not specified, are taken from

             the session path. The file name shall not contain wild cards

             ('?' or '*' characters) and illegal characters like 

             '<', '>', ':', '"', '/', '|' and '\000'. Backslash '\\' character 

             is allowed only as a path delimiter. The filename containing only 

             white space characters (See TChar::IsSpace()) is also illegal.

@param aMode The mode in which the file is opened. The access mode is

             automatically set to EFileWrite. See TFileMode.

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

        error codes.

@see TFileMode

@capability Dependent If the path in aName starts with /Sys then capability Tcb is required

@capability Dependent If the path in aName starts with /Resource then capability Tcb is required

@capability Dependent If the path in aName starts with /Private and does not match this process'

					  SID then AllFiles capability is required.

*/

	{

	TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFileReplace, MODULEUID, aFs.Handle(), aMode, aName);

	aMode &= ~EFileBigFile;

	TInt r = CreateSubSession(aFs,EFsFileReplace,TIpcArgs(&aName,aMode));

	TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFileReplaceReturn, MODULEUID, r, SubSessionHandle());

	return r;

	}

EFSRV_EXPORT_C TInt RFile::Temp(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aMode)

/**

Creates and opens a temporary file with a unique name for writing and reading.

Notes:

1. To close the file, use Close()

@param aFs   The file server session.

@param aPath The directory in which the file is created.

@param aName On return, contains the full path and file name of the file.

             The filename is guaranteed to be unique within the directory

             specified by aPath.

@param aMode The mode in which the file is opened. The access mode is

             automatically set to EFileWrite. See TFileMode.

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

        error codes.

@see TFileMode

@capability Dependent If aPath starts with /Sys then capability Tcb is required

@capability Dependent If aPath starts with /Resource then capability Tcb is required

@capability Dependent If aPath starts with /Private and does not match this process'

					  SID then AllFiles capability is required.

*/

	{

   	TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFileTemp, MODULEUID, aFs.Handle(), aPath, aMode);

	aMode &= ~EFileBigFile;

	TInt r = CreateSubSession(aFs,EFsFileTemp,TIpcArgs(&aPath,aMode,&aName));

	TRACERETMULT3(UTF::EBorder, UTraceModuleEfsrv::EFileTempReturn, MODULEUID, r, SubSessionHandle(), aName);

	return r;

	}

EFSRV_EXPORT_C TInt RFile::Read(TDes8& aDes) const

/**

Reads from the file at the current position.

This is a synchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into 

it. Therefore, when reading through a file,the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

@param aDes Descriptor into which binary data is read. Any existing contents 

            are overwritten. On return, its length is set to the number of

            bytes read.

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

        codes.

@see TDesC8::Length

*/

	{

	TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFileRead1, MODULEUID, Session().Handle(), SubSessionHandle(), aDes.MaxLength());

	TInt r = SendReceive(EFsFileRead,TIpcArgs(&aDes,aDes.MaxLength(),I64LOW(KCurrentPosition64)));

	TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFileRead1Return, MODULEUID, r, aDes.Length());

	return r;

	}

EFSRV_EXPORT_C void RFile::Read(TDes8& aDes,TRequestStatus& aStatus) const

/**

Reads from the file at the current position.

This is an asynchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into 

it. Therefore, when reading through a file,the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

@param aDes    Descriptor into which binary data is read. Any existing contents 

               are overwritten. On return, its length is set to the number of

               bytes read.

               NB: this function is asynchronous and the request that it

               represents may not complete until some time after the call

               to the function has returned. It is important, therefore, that

               this descriptor remain valid, or remain in scope, until you have

               been notified that the request is complete.

@param aStatus Request status. On completion contains:

       KErrNone, if successful, otherwise one of the other system-wide error codes.

@see TDesC8::Length       

*/

	{

	TRACE4(UTF::EBorder, UTraceModuleEfsrv::EFileRead2, MODULEUID, Session().Handle(), SubSessionHandle(), aDes.MaxLength(), &aStatus);

    RSubSessionBase::SendReceive(EFsFileRead,TIpcArgs(&aDes,aDes.MaxLength(),I64LOW(KCurrentPosition64)),aStatus);

	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFileRead2Return, MODULEUID);

	}

EFSRV_EXPORT_C TInt RFile::Read(TDes8& aDes,TInt aLength) const

/**

Reads the specified number of bytes of binary data from the file at the current position.

This is a synchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into 

it. Therefore, when reading through a file,the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

Assuming aLength is less than the maximum length of the descriptor, the only circumstances 

in which Read() can return fewer bytes than requested, is when the end of 

file is reached or if an error occurs.

@param aDes    Descriptor into which binary data is read. Any existing

               contents are overwritten. On return, its length is set to

               the number of bytes read.

@param aLength The number of bytes to be read from the file into the descriptor. 

               If an attempt is made to read more bytes than the descriptor's 

               maximum length, the function returns KErrOverflow.

               This value must not be negative, otherwise the function

               returns KErrArgument.

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

        codes.

*/

	{

	TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFileRead1, MODULEUID, Session().Handle(), SubSessionHandle(), aLength);

	if (aLength==0)

		{

		aDes.Zero();

		return(KErrNone);

		}

	else if(aLength>aDes.MaxLength())

		{

		return(KErrOverflow);

		}

	TInt r = SendReceive(EFsFileRead,TIpcArgs(&aDes,aLength,I64LOW(KCurrentPosition64)));

	TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFileRead1Return, MODULEUID, r, aDes.Length());

	return r;

	}

EFSRV_EXPORT_C void RFile::Read(TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const

/**

Reads a specified number of bytes of binary data from the file at the current position.

This is an asynchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into it.

Therefore, when reading through a file, the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

Assuming aLength is less than the maximum length of the descriptor, the only

circumstances in which Read() can return fewer bytes than requested is when

the end of file is reached or if an error has occurred.

@param aDes    Descriptor into which binary data is read. Any existing

               contents are overwritten. On return, its length is set to the

               number of bytes read.

               NB: this function is asynchronous and the request that it

               represents may not complete until some time after the call

               to the function has returned. It is important, therefore, that

               this descriptor remain valid, or remain in scope, until you have

               been notified that the request is complete.

@param aLength The number of bytes to be read from the file into the descriptor. 

               If an attempt is made to read more bytes than the descriptor's

               maximum length, then the function updates aStatus parameter with KErrOverflow.

               It must not be negative otherwise the function updates aStatus with KErrArgument.

@param aStatus Request status. On completion contains KErrNone if successful, 

               otherwise one of the other system-wide error codes.

*/

	{

	TRACE4(UTF::EBorder, UTraceModuleEfsrv::EFileRead2, MODULEUID, Session().Handle(), SubSessionHandle(), aLength, &aStatus);

	if (aLength==0)

		{

		aDes.Zero();

		TRequestStatus* req=(&aStatus);

		User::RequestComplete(req,KErrNone);

		return;

		}

	else if(aLength>aDes.MaxLength())

		{

		TRequestStatus* req=(&aStatus);

		User::RequestComplete(req,KErrOverflow);

		return;

		}

	RSubSessionBase::SendReceive(EFsFileRead,TIpcArgs(&aDes,aLength,I64LOW(KCurrentPosition64)),aStatus);

	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFileRead2Return, MODULEUID);

	}

EFSRV_EXPORT_C TInt RFile::Read(TInt aPos,TDes8& aDes) const

/**

Reads from the file at the specified offset within the file

This is a synchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into it.

Therefore, when reading through a file, the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

@param aPos Position of first byte to be read.  This is an offset from

            the start of the file. If no position is specified, reading

            begins at the current file position. 

            If aPos is beyond the end of the file, the function returns

            a zero length descriptor.

@param aDes The descriptor into which binary data is read. Any existing content

            is overwritten. On return, its length is set to the number of

            bytes read.

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

        codes.

@panic FSCLIENT 19 if aPos is negative.        

*/

	{

	TRACE5(UTF::EBorder, UTraceModuleEfsrv::EFileRead3, MODULEUID, Session().Handle(), SubSessionHandle(), aPos, 0, aDes.MaxLength());

	__ASSERT_ALWAYS(aPos>=0,Panic(EPosNegative));

	TInt r = SendReceive(EFsFileRead,TIpcArgs(&aDes,aDes.MaxLength(),aPos));

	TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFileRead3Return, MODULEUID, r, aDes.Length());

	return r;

	}

EFSRV_EXPORT_C void RFile::Read(TInt aPos,TDes8& aDes,TRequestStatus& aStatus) const

/**

Reads from the file at the specified offset within the file.

This is an asynchronous function.

Note that when an attempt is made to read beyond the end of the file,

no error is returned. 

The descriptor's length is set to the number of bytes read into it.

Therefore, when reading through a file, the end of file has been reached 

when the descriptor length, as returned by TDesC8::Length(), is zero.

@param aPos    Position of first byte to be read. This is an offset from

               the start of the file. If no position is specified, 

               reading begins at the current file position.

               If aPos is beyond the end of the file, the function returns

               a zero length descriptor.

@param aDes    The descriptor into which binary data is read. Any existing

               content is overwritten. On return, its length is set to

               the number of bytes read.

               NB: this function is asynchronous and the request that it

               represents may not complete until some time after the call

               to the function has returned. It is important, therefore, that

               this descriptor remain valid, or remain in scope, until you have

               been notified that the request is complete.

@param aStatus The request status. On completion, contains an error code of KErrNone 

               if successful, otherwise one of the other system-wide error codes.

@panic FSCLIENT 19 if aPos is negative.        

*/

	{

	TRACE6(UTF::EBorder, UTraceModuleEfsrv::EFileRead4, MODULEUID, Session().Handle(), SubSessionHandle(), aPos, 0, aDes.MaxLength(), &aStatus);

	__ASSERT_ALWAYS(aPos>=0,Panic(EPosNegative));

	RSubSessionBase::SendReceive(EFsFileRead,TIpcArgs(&aDes,aDes.MaxLength(),aPos),aStatus);

	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFileRead4Return, MODULEUID);

	}

EFSRV_EXPORT_C TInt RFile::Read(TInt aPos,TDes8& aDes,TInt aLength) const

/**