// Copyright (c) 2007-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:

// Template_plugin.cpp

// 

//

#include "exclusiveaccess_plugin.h"

#include "plugincommon.h"

#include <f32pluginutils.h>

/**

Leaving New function for the plugin

@internalComponent

*/

CExclusiveAccessPlugin* CExclusiveAccessPlugin::NewL()

	{

	CExclusiveAccessPlugin* self = new(ELeave) CExclusiveAccessPlugin;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

	return self;

	}

/**

Constructor for the plugin

@internalComponent

*/

CExclusiveAccessPlugin::CExclusiveAccessPlugin() : iInterceptsEnabled(EFalse),

									 iLogging(ETrue)

	{

	}

void CExclusiveAccessPlugin::ConstructL()

	{

	}

/**

The destructor for the plugin

@internalComponent

*/

CExclusiveAccessPlugin::~CExclusiveAccessPlugin()

	{

	iFs.Close();

	}

/**

Initialise the plugin.

@internalComponent

*/

void CExclusiveAccessPlugin::InitialiseL()

	{

	User::LeaveIfError(iFs.Connect());

	CleanupClosePushL(iFs);

	_LOG(_L("CExclusiveAccessPlugin InitialiseL"));

	EnableInterceptsL();

	CleanupStack::Pop(); // iFs

	}

/**

Enable the plugin's intercepts.

@internalComponent

*/

void CExclusiveAccessPlugin::EnableInterceptsL()

	{

	if (iInterceptsEnabled) return;

	User::LeaveIfError(RegisterIntercept(EFsFileRead,		EPrePostIntercept));

	User::LeaveIfError(RegisterIntercept(EFsFileWrite,		EPrePostIntercept));

	_LOG(_L("CExclusiveAccessPlugin : Enabled intercepts."));

	iInterceptsEnabled = ETrue;

	}

/**

Disable the plugin's intercepts.

@internalComponent

*/

void CExclusiveAccessPlugin::DisableInterceptsL()

	{

	if (!iInterceptsEnabled) return;

	User::LeaveIfError(UnregisterIntercept(EFsFileRead,		EPrePostIntercept));

	User::LeaveIfError(UnregisterIntercept(EFsFileWrite,	EPrePostIntercept));

	_LOG(_L("CExclusiveAccessPlugin : Disabled intercepts."));

	iInterceptsEnabled = EFalse;

	}

/**

Handle requests

@internalComponent

*/

TInt CExclusiveAccessPlugin::DoRequestL(TFsPluginRequest& aRequest)

	{

	TInt err = KErrNone;

	TInt function = aRequest.Function();

	switch(function)

		{

		case EFsFileRead:

			err = FsFileReadL(aRequest);

			break;

		case EFsFileWrite:

			err = FsFileWriteL(aRequest);

			break;

		default:

			//Only registered for Read/Write

			break;

		}

	return err;

	}

/*Test to ensure that when a file has been opened for exclusive access,

 * i.e. readonly, that froma  plugin we can still read from it

 */

TInt CExclusiveAccessPlugin::FsFileReadL(TFsPluginRequest& aRequest)

	{

	if(!aRequest.IsPostOperation()) // pre-operation

		{

		RFilePlugin file(aRequest);

		TInt err = file.AdoptFromClient();

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		TInt64 pos;

		err = aRequest.Read(TFsPluginRequest::EPosition, pos); // get pos

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		TInt length;

		err = aRequest.Read(TFsPluginRequest::ELength, length); //get length

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		if(length>265)

			length=256;

		//we should check that this file is in fact registered as read only?

		//if not.. User::Invariant()?

		TEntry entry;

		RFsPlugin rfsplugin(aRequest);

		err = rfsplugin.Connect();

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		TFileName fileName;

		err = aRequest.FileName(fileName);

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		err = rfsplugin.Entry(fileName, entry);

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		//can we read a readonly file? - should be fine.

		TBuf8<256> data;

		err = file.Read(pos,data,length);

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		file.Close();

		rfsplugin.Close();

		}

	return KErrNone;

	}

/*Test to ensure that when a file has been opened for exclusive access,

 * i.e. readonly, that from a plugin we can still write to it regardless

 */

TInt CExclusiveAccessPlugin::FsFileWriteL(TFsPluginRequest& aRequest)

	{

	if(!aRequest.IsPostOperation()) // pre-operation

		{

		//Make sure that the file is read only.

		RFilePlugin file(aRequest);

		TInt err = file.AdoptFromClient();

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		RFsPlugin rfsplugin(aRequest);

		err = rfsplugin.Connect();

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		TEntry entry;

		err = rfsplugin.Entry(aRequest.Src().FullName(), entry);

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

//		if(!entry.IsReadOnly())

//			{

//			//this test should only being being used for read only files.

//			User::Invariant();

//			}

		TInt64 pos;

		err = aRequest.Read(TFsPluginRequest::EPosition, pos); //get pos

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		TInt length;

		err = aRequest.Read(TFsPluginRequest::ELength, length); //get length

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		TBuf8<1024> data;

		err = aRequest.Read(TFsPluginRequest::EData, data); //get data to write

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		//Now test that we can actually write to this read-only file

		//Should pass, kerrnone.

		err = file.Write(pos,data,length);

		iLastError = err;

		iLineNumber = __LINE__;

		if(err!=KErrNone)

			return err;

		file.Close();

		//We've performed the efsfilewrite, so return kerrcompletion.

		return KErrCompletion;		

		}

	return KErrNone;

	}

CFsPluginConn* CExclusiveAccessPlugin::NewPluginConnL()

	{

	return new(ELeave) CExclusiveAccessPluginConn();

	}

//Synchronous RPlugin::DoControl

TInt CExclusiveAccessPlugin::FsPluginDoControlL(CFsPluginConnRequest& aRequest)

	{	

	TInt err = KErrNone;

	//We can use this to set the drive

	//We can store this as a member of this class.

	TInt function = aRequest.Function();

	TPckg<TInt> errCodeDes(iLastError);

	TPckg<TInt> lineNumberDes(iLineNumber);

	switch(function)

		{

		case KPluginGetError:

			{

			TRAP(err,aRequest.WriteParam1L(errCodeDes));

			TRAP(err,aRequest.WriteParam2L(lineNumberDes));

			break;

			}

		default:

			break;

		}

	return err;

	}

TInt CExclusiveAccessPluginConn::DoControl(CFsPluginConnRequest& aRequest)

	{

	return ((CExclusiveAccessPlugin*)Plugin())->FsPluginDoControlL(aRequest);

	}

void CExclusiveAccessPluginConn::DoRequest(CFsPluginConnRequest& aRequest)

	{

	DoControl(aRequest);

	}

void CExclusiveAccessPluginConn::DoCancel(TInt /*aReqMask*/)

	{

	}

//factory functions

class CExclusiveAccessPluginFactory : public CFsPluginFactory

	{

public:

	CExclusiveAccessPluginFactory();

	virtual TInt Install();			

	virtual CFsPlugin* NewPluginL();

	virtual CFsPlugin* NewPluginConnL();

	virtual TInt UniquePosition();

	};

/**

Constructor for the plugin factory

@internalComponent

*/

CExclusiveAccessPluginFactory::CExclusiveAccessPluginFactory()

	{

	}

/**

Install function for the plugin factory

@internalComponent

*/

TInt CExclusiveAccessPluginFactory::Install()

	{

	SetSupportedDrives(KPluginSupportAllDrives);

	return(SetName(&KExclusiveAccessPluginName));

	}

/**

@internalComponent

*/

TInt CExclusiveAccessPluginFactory::UniquePosition()

	{

	return(KExclusiveAccessPos);

	}

/**

Plugin factory function

@internalComponent

*/

CFsPlugin* CExclusiveAccessPluginFactory::NewPluginL()

	{

	return CExclusiveAccessPlugin::NewL();

	}

/**

Plugin factory function

@internalComponent

*/

CFsPlugin* CExclusiveAccessPluginFactory::NewPluginConnL()

	{

	return CExclusiveAccessPlugin::NewL();

	}

/**

Create a new Plugin

@internalComponent

*/

extern "C" {

EXPORT_C CFsPluginFactory* CreateFileSystem()

	{

	return(new CExclusiveAccessPluginFactory());

	}

}