// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // f32\sfile\sf_plugin_shim.cpp

 // 

 //

 #include "cl_std.h"

 #include "sf_std.h"

 /*******************************************************

 *						RFsPlugin					   *

 *******************************************************/

 EXPORT_C RFsPlugin::RFsPlugin(TFsPluginRequest& aRequest, TBool aDirectToDrive)

   : iSessionHelper(&aRequest, aDirectToDrive)

 	{

 	SetReturnedHandle(KNullHandle);

 	}

 EXPORT_C RFsPlugin::~RFsPlugin()

 	{

 	Close();

 	}

 EXPORT_C TInt RFsPlugin::Connect()

 /**

 Connects a file server plugin to the file server.

 To end the file server session, use Close().

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

 */

 	{

 	return KErrNone;

 	}

 EXPORT_C void RFsPlugin::Close()

 /**

 Closes a file server plugin session.

 */

 	{

 	SetReturnedHandle(KNullHandle);

 	}

 EXPORT_C TInt RFsPlugin::Delete(const TDesC& aName)

 /**

 Deletes a single file.

 @see RFs::Delete

 */

 	{

 	return(RFs::Delete(aName));

 	}

 EXPORT_C TInt RFsPlugin::Rename(const TDesC& aOldName,const TDesC& aNewName)

 /**

 Renames a single file or directory.

 @see RFs::Rename

 */

 	{

 	return(RFs::Rename(aOldName, aNewName));

 	}

 EXPORT_C TInt RFsPlugin::Replace(const TDesC& aOldName,const TDesC& aNewName)

 /**

 Replaces a single file with another.

 @see RFs::Replace

 */

 	{

 	return(RFs::Replace(aOldName, aNewName));

 	}

 EXPORT_C TInt RFsPlugin::Entry(const TDesC& aName,TEntry& aEntry) const

 /**

 Gets the entry details for a file or directory.

 @see RFs::Entry

 */

 	{

 	return(RFs::Entry(aName, aEntry));

 	}

 EXPORT_C TInt RFsPlugin::SetEntry(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask)

 /**

 Sets both the attributes and the last modified date and time for a file or directory.

 @see RFs::SetEntry

 */

 	{

 	return(RFs::SetEntry(aName,aTime,aSetAttMask,aClearAttMask));

 	}

 EXPORT_C TInt RFsPlugin::ReadFileSection(const TDesC& aName,TInt64 aPos,TDes8& aDes,TInt aLength) const

 /**

 Reads data from a file without opening it.

 The contents of the	file can be accessed regardless of the file's lock state.

 @see RFs::ReadFileSection

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	return(RFs::ReadFileSection(aName,I64LOW(aPos),aDes,aLength));

 #else

 	return(RFs::ReadFileSection(aName,aPos,aDes,aLength));

 #endif

 	}

 EXPORT_C TInt RFsPlugin::Volume(TVolumeInfo &aVol, TInt aDrive) const

 /**

 Gets volume information for a formatted device.

 @see RFs::Volume

 */

 	{

 	return (RFs::Volume(aVol, aDrive));

 	}

 TInt RFsPlugin::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const

 	{

 	return iSessionHelper.SendReceive(aFunction, aArgs);

 	}

 TInt RFs::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const

 	{

 	if(Handle())

 		return RSessionBase::SendReceive(aFunction, aArgs);

 	return ((RFsPlugin*) this)->SendReceive(aFunction, aArgs);

 	}

 /*******************************************************

 *						RFilePlugin					   *

 *******************************************************/

 EXPORT_C RFilePlugin::RFilePlugin(TFsPluginRequest& aRequest, TBool aDirectToDrive)

   : iSessionHelper(&aRequest, aDirectToDrive)

 	{

 	SetHandle(KErrBadHandle);

 	SetSubSessionHandle(KErrBadHandle);

 	}

 EXPORT_C RFilePlugin::~RFilePlugin()

 	{

 	Close();

 	}

 EXPORT_C TInt RFilePlugin::Open(const TDesC& aName,TUint aMode)

 /**

 Opens an existing file for reading or writing.

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

 @see RFile::Open

 */

 	{

 	RFs fs;

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

 	return(CreateSubSession(fs,EFsFileOpen,TIpcArgs(&aName,aMode)));

 	}

 EXPORT_C void RFilePlugin::Close()

 /**

 Closes the file.

 @see RFile::Close

 */

 	{

 	CloseSubSession(EFsFileSubClose);

 	SetSubSessionHandle(KErrBadHandle);

 	}

 EXPORT_C TInt RFilePlugin::Create(const TDesC& aName,TUint aFileMode)

 /**

 Closes the file.

 @see RFile::Create

 */

 	{

 	RFs fs;

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

 	return(CreateSubSession(fs,EFsFileCreate,TIpcArgs(&aName,aFileMode)));

 	}

 EXPORT_C TInt RFilePlugin::Replace(const TDesC& aName,TUint aFileMode)

 /**

 Closes the file.

 @see RFile::Replace

 */

 	{

 	RFs fs;

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

 	return(CreateSubSession(fs,EFsFileReplace,TIpcArgs(&aName,aFileMode)));

 	}

 EXPORT_C TInt RFilePlugin::Temp(const TDesC& aPath,TFileName& aName,TUint aFileMode)

 /**

 Closes the file.

 @see RFile::Temp

 */

 	{

 	RFs fs;

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

 	return(CreateSubSession(fs,EFsFileTemp,TIpcArgs(&aPath,aFileMode,&aName)));

 	}

 EXPORT_C TInt RFilePlugin::AdoptFromClient()

 /**

 Closes the file.

 @see RFile::AdoptFromClient

 */

 	{

 	TFsPluginRequest* request = iSessionHelper.Request();

 	if(request == NULL)

 		return KErrBadHandle;

 	TInt clientSubSessionHandle;

 	TInt err = request->ClientSubSessionHandle(clientSubSessionHandle);

 	if (err != KErrNone)

 		return err;

 	RFs fs;

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

 	err = CreateSubSession(fs,EFsFileDuplicate, TIpcArgs(clientSubSessionHandle, ETrue));

 	if (err != KErrNone)

 		return err;

 	SetSubSessionHandle(SubSessionHandle() ^ KSubSessionMangleBit);

 	return err;

 	}

 EXPORT_C TInt RFilePlugin::TransferToClient()

 /**

 Closes the file.

 @see RFile::TransferToClient

 */

 	{

 	TFsPluginRequest* request = iSessionHelper.Request();

 	if(request == NULL)

 		return KErrBadHandle;

 	// This doesn't behave like a standard duplicate as we're running in the context of the

 	// client's session.  Instead, we can simply return our subsession handle to the client.

 	TRAPD(err, request->Request()->WriteL(KMsgPtr3, TPckgC<TInt>(SubSessionHandle())));

 	// Next we have to free up the close request reserved for our internal subsession

 	// otherwise two messages will be reserved for the client...

 	RequestAllocator::OpenSubFailed(request->Request()->Session());

 	// And now we're done - we don't bother closing, as the client now completely owns the handle

 	SetSubSessionHandle(KErrBadHandle);

 	return err;

 	}

 EXPORT_C TInt RFilePlugin::Write(TInt64 aPos, const TDesC8& aDes)

 /**

 Writes to the file at the specified offset within the file

 @see RFile::Write

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	return RFile::Write(I64LOW(aPos), aDes);

 #else

 	return RFile64::Write(aPos, aDes);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::Write(TInt64 aPos,const TDesC8& aDes,TInt aLen)

 /**

 Writes the specified number of bytes to the file at the specified offset within the file.

 @see RFile::Write

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	return RFile::Write(I64LOW(aPos), aDes, aLen);

 #else

 	return RFile64::Write(aPos, aDes, aLen);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::Read(TInt64 aPos,TDes8& aDes) const

 /**

 Reads from the file at the specified offset within the file

 @see RFile::Read

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	return RFile::Read(I64LOW(aPos), aDes);

 #else

 	return RFile64::Read(aPos, aDes);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::Read(TInt64 aPos,TDes8& aDes,TInt aLen) const

 /**

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

 offset within the file.

 @see RFile::Read

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	return RFile::Read(I64LOW(aPos), aDes, aLen);

 #else

 	return RFile64::Read(aPos, aDes, aLen);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::Size(TInt64& aSize) const

 /**

 Gets the current file size.

 @see RFile::Size

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	TInt size = I64LOW(aSize);

 	TInt err = RFile::Size(size);

 	aSize = size;

 	return err;

 #else

 	return RFile64::Size(aSize);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::SetSize(TInt64 aSize)

 /**

 Sets the file size.

 @see RFile::SetSize

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	return RFile::SetSize(I64LOW(aSize));

 #else

 	return RFile64::SetSize(aSize);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::Lock(TInt64 aPos, TInt64 aLength) const

 /**

 Locks a region within the file as defined by a range of bytes.

 @see RFile::Lock

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	return RFile::Lock(I64LOW(aPos), I64LOW(aLength));

 #else

 	return RFile64::Lock(aPos, aLength);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::UnLock(TInt64 aPos, TInt64 aLength) const

 /**

 Unlocks a region within the file as defined by a range of bytes.

 @see RFile::UnLock

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	return RFile::UnLock(I64LOW(aPos), I64LOW(aLength));

 #else

 	return RFile64::UnLock(aPos, aLength);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::Seek(TSeek aMode,TInt64& aPos) const

 /**

 Sets the the current file position.

 @see RFile::Seek

 */

 	{

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 	TInt position = I64LOW(aPos);

 	TInt err = RFile::Seek(aMode, position);

 	if(err != KErrNone)

 		return err;

 	aPos = position;

 	return KErrNone;

 #else

 	return RFile64::Seek(aMode, aPos);

 #endif

 	}

 EXPORT_C TInt RFilePlugin::Flush()

 /**

 Commits data to the storage device and flushes internal buffers without closing

 the file.

 @see RFile::Flush

 */

 	{

 	return RFile::Flush();

 	}

 EXPORT_C TInt RFilePlugin::Att(TUint& aVal) const

 /**

 Gets the file's attributes.

 @see RFile::Att

 */

 	{

 	return RFile::Att(aVal);

 	}

 EXPORT_C TInt RFilePlugin::SetAtt(TUint aSetAttMask,TUint aClearAttMask)

 /**

 Sets or clears file attributes using two bitmasks.

 @see RFile::SetAtt

 */

 	{

 	return RFile::SetAtt(aSetAttMask, aClearAttMask);

 	}

 EXPORT_C TInt RFilePlugin::Modified(TTime& aTime) const

 /**

 Gets local date and time the file was last modified, in universal time.

 @see RFile::Modified

 */

 	{

 	return RFile::Modified(aTime);

 	}

 EXPORT_C TInt RFilePlugin::SetModified(const TTime& aTime)

 /**

 Sets the date and time the file was last modified. UTC date and time should be used.

 @see RFile::SetModified

 */

 	{

 	return RFile::SetModified(aTime);

 	}

 EXPORT_C TInt RFilePlugin::Set(const TTime& aTime,TUint aMask,TUint aVal)

 /**

 Sets the file’s attributes, and the date and time it was last modified.

 @see RFile::Set

 */

 	{

 	return RFile::Set(aTime, aMask, aVal);

 	}

 EXPORT_C TInt RFilePlugin::ChangeMode(TFileMode aNewMode)

 /**

 Switches an open file's access mode between EFileShareExclusive and EFileShareReadersOnly.

 @see RFile::ChangeMode

 */

 	{

 	return RFile::ChangeMode(aNewMode);

 	}

 EXPORT_C TInt RFilePlugin::Rename(const TDesC& aNewName)

 /**

 Renames a file.

 @see RFile::Rename

 */

 	{

 	return RFile::Rename(aNewName);

 	}

 void RFilePlugin::SetHandle(TInt aHandle)

 	{

 	*(((TInt*) this) + 0) = aHandle;

 	}

 void RFilePlugin::SetSubSessionHandle(TInt aHandle)

 	{

 	*(((TInt*) this) + 1) = aHandle;

 	}

 TInt RFilePlugin::CreateSubSession(const RSessionBase& aSession, TInt aFunction, const TIpcArgs& aArgs)

 	{

 	TInt reply;

 	TInt err = iSessionHelper.CreateSubSession(aSession, aFunction, aArgs, &reply);

 	if(err == KErrNone)

 		SetSubSessionHandle(reply);

 	return(err);

 	}

 void RFilePlugin::CloseSubSession(TInt aFunction)

 	{

 	if (SubSessionHandle())

 		{

 		SendReceive(aFunction,TIpcArgs(TIpcArgs::ENothing,TIpcArgs::ENothing,TIpcArgs::ENothing,SubSessionHandle()));

 		}

 	SetHandle(KErrBadHandle);

 	SetSubSessionHandle(KErrBadHandle);

 	}

 TInt RFilePlugin::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const

 	{

 	return iSessionHelper.SendReceive(aFunction, aArgs, ((RFilePlugin*) this)->SubSessionHandle());

 	}

 TInt RFile::CreateSubSession(const RSessionBase& aSession,TInt aFunction,const TIpcArgs& aArgs)

 	{

 	if(SubSessionHandle() == KErrBadHandle)

 		return ((RFilePlugin*) this)->CreateSubSession(aSession, aFunction, aArgs);

 	return RSubSessionBase::CreateSubSession(aSession, aFunction, aArgs);

 	}

 void RFile::CloseSubSession(TInt aFunction)

 	{

 	if((Session().Handle() ^ CObjectIx::ENoClose) != KErrBadHandle)

 		RSubSessionBase::CloseSubSession(aFunction);

 	else

 		((RFilePlugin*) this)->CloseSubSession(aFunction);

 	}

 TInt RFile::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const

 	{

 	if((Session().Handle() ^ CObjectIx::ENoClose) != KErrBadHandle)

 		return RSubSessionBase::SendReceive(aFunction, aArgs);

 	return ((RFilePlugin*) this)->SendReceive(aFunction, aArgs);

 	}

 /*******************************************************

 *						RDirPlugin					   *

 *******************************************************/

 EXPORT_C RDirPlugin::RDirPlugin(TFsPluginRequest& aRequest, TBool aDirectToDrive)

   : iSessionHelper(&aRequest, aDirectToDrive)

 	{

 	SetHandle(KErrBadHandle);

 	SetSubSessionHandle(KErrBadHandle);

 	}

 EXPORT_C RDirPlugin::~RDirPlugin()

 	{

 	Close();

 	}

 EXPORT_C TInt RDirPlugin::Open(const TDesC& aMatchName,const TUidType& aUidType)

 /**

 Opens a directory using the specified UID type to filter the

 directory entry types that will subsequently be read.

 @see RDir::Open

 */

 	{

 	RFs fs;

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

 	TPckgC<TUidType> pckgUid(aUidType);

 	return(CreateSubSession(fs,EFsDirOpen,TIpcArgs(&aMatchName,KEntryAttAllowUid,&pckgUid)));

 	}

 EXPORT_C TInt RDirPlugin::Open(const TDesC& aMatchName,TUint anAttMask)

 /**

 Opens a directory using an attribute bitmask to filter the directory entry

 types that will subsequently be read.

 @see RDir::Open

 */

 	{

 	RFs fs;

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

 	TUidType uidType(TUid::Null(),TUid::Null(),TUid::Null());

 	TPckgC<TUidType> pckgUid(uidType);

 	return(CreateSubSession(fs,EFsDirOpen,TIpcArgs(&aMatchName,anAttMask,&pckgUid)));

 	}

 EXPORT_C void RDirPlugin::Close()

 /**

 Closes the the directory.

 @see RDir::Close

 */

 	{

 	CloseSubSession(EFsDirSubClose);

 	SetSubSessionHandle(KErrBadHandle);

 	}

 EXPORT_C TInt RDirPlugin::Read(TEntryArray& aArray)

 /**

 Reads all filtered directory entries into the specified array.

 @see RDir::Read

 */

 	{

 	return RDir::Read(aArray);

 	}

 EXPORT_C TInt RDirPlugin::Read(TEntry& aEntry)

 /**

 Reads all filtered directory entries into the specified array.

 @see RDir::Read

 */

 	{

 	return RDir::Read(aEntry);

 	}

 void RDirPlugin::SetHandle(TInt aHandle)

 	{

 	*(((TInt*) this) + 0) = aHandle;

 	}

 void RDirPlugin::SetSubSessionHandle(TInt aHandle)

 	{

 	*(((TInt*) this) + 1) = aHandle;

 	}

 TInt RDirPlugin::CreateSubSession(const RSessionBase& aSession, TInt aFunction, const TIpcArgs& aArgs)

 	{

 	TInt reply;

 	TInt err = iSessionHelper.CreateSubSession(aSession, aFunction, aArgs, &reply);

 	if(err == KErrNone)

 		SetSubSessionHandle(reply);

 	return(err);

 	}

 void RDirPlugin::CloseSubSession(TInt aFunction)

 	{

 	if (SubSessionHandle())

 		{

 		SendReceive(aFunction,TIpcArgs(TIpcArgs::ENothing,TIpcArgs::ENothing,TIpcArgs::ENothing,SubSessionHandle()));

 		}

 	SetHandle(KErrBadHandle);

 	SetSubSessionHandle(KErrBadHandle);

 	}

 TInt RDirPlugin::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const

 	{

 	return iSessionHelper.SendReceive(aFunction, aArgs, ((RDirPlugin*) this)->SubSessionHandle());

 	}

 TInt RDir::SendReceive(TInt aFunction,const TIpcArgs& aArgs) const

 	{

 	if((Session().Handle() ^ CObjectIx::ENoClose) != KErrBadHandle)

 		return RSubSessionBase::SendReceive(aFunction, aArgs);

 	return ((RDirPlugin*) this)->SendReceive(aFunction, aArgs);

 	}

 /*******************************************************

 *				TFsPluginSessionHelper				   *

 *******************************************************/

 TPluginSessionHelper::TPluginSessionHelper()

 	{ memclr(this, sizeof(TPluginSessionHelper)); }

 TPluginSessionHelper::TPluginSessionHelper(TFsPluginRequest* aRequest, TBool aDirectToDrive)

   : iPlugin(aRequest->Request()->iCurrentPlugin),

 	iSession(aRequest->Request()->Session()),

 	iDirectToDrive(aDirectToDrive),

     iRequest(aRequest)

 	{

 	// need to initialise RLocalMessage with client session

 	*((RMessage2*) &iMessage) = aRequest->Message();

 	iMessage.InitHandle();	// set handle to KLocalMessageHandle

 	memclr(iSpare, sizeof(iSpare));

 	}

 TInt TPluginSessionHelper::CreateSubSession(const RSessionBase& aSession, TInt aFunction, const TIpcArgs& aArgs, TInt* aReply)

 	{

 	(void)aSession;

 	// Init message

 	TIpcArgs args;

 	args.iArgs[0] = aArgs.iArgs[0];

 	args.iArgs[1] = aArgs.iArgs[1];

 	args.iArgs[2] = aArgs.iArgs[2];

 	args.iFlags = aArgs.iFlags&((1<<(3*TIpcArgs::KBitsPerType))-1);

 	TPckgBuf<TInt> reply;

 	args.Set(3,&reply);

 	// copy session pointer

 	RLocalMessage message = iMessage;

 	message.SetFunction(aFunction);

 	message.SetArgs(args);

 	TInt err = Dispatch(aFunction, args);

 	if (err == KErrNone)

 		*aReply = reply();

 	return err;

 	}

 TInt TPluginSessionHelper::Dispatch(TInt aFunction, TIpcArgs& aArgs) const

 	{

 	// copy session pointer

 	RLocalMessage message = iMessage;

 	message.SetFunction(aFunction);

 	message.SetArgs(aArgs);

 	// allocate request

 	CFsClientMessageRequest* newRequest;

 	const TOperation& oP = OperationArray[aFunction & KIpcFunctionMask];

 	TInt err = RequestAllocator::GetMessageRequest(oP, message, newRequest);

 	if (err != KErrNone)

 		return err;

 	newRequest->Set(message, oP, iSession);

 	//This is wrong. drive number is set in TFsXxx::initialise

 	//newRequest->SetDrive(&TheDrives[iPlugin->Drive()]);

 	newRequest->iCurrentPlugin = iPlugin;

 	newRequest->iOwnerPlugin   = iPlugin;

 	newRequest->iDirectToDrive = iDirectToDrive;

 	newRequest->Dispatch();

 	// NOTE : newRequest will be free'd by the File Server before completing the

 	//        request so it's not safe to touch the request from now on...

 	return(iPlugin->WaitForRequest());

 	}

 TInt TPluginSessionHelper::SendReceive(TInt aFunction, const TIpcArgs& aArgs, TInt aSubSessionHandle) const

 	{

 	// Init message

 	TIpcArgs args;

 	args.iArgs[0] = aArgs.iArgs[0];

 	args.iArgs[1] = aArgs.iArgs[1];

 	args.iArgs[2] = aArgs.iArgs[2];

 	args.iFlags   = aArgs.iFlags&((1<<(3*TIpcArgs::KBitsPerType))-1);

 	args.iArgs[3] = aSubSessionHandle;

 	return Dispatch(aFunction, args);

 	}

 TInt TPluginSessionHelper::SendReceive(TInt aFunction, const TIpcArgs& aArgs) const

 	{

 	// Init message

 	TIpcArgs args;

 	args.iArgs[0] = aArgs.iArgs[0];

 	args.iArgs[1] = aArgs.iArgs[1];

 	args.iArgs[2] = aArgs.iArgs[2];

 	args.iArgs[3] = aArgs.iArgs[3];

 	args.iFlags = aArgs.iFlags&((1<<(3*TIpcArgs::KBitsPerType))-1);

 	return Dispatch(aFunction, args);

 	}

 GLDEF_C void Panic(TClientPanic aPanic)

 //

 // Panic the current client with a file server client side panic.

 //

 	{

 	User::Panic(_L("FS_PLUGIN_CLIENT panic"),aPanic);

 	}