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

// f32test\plugins\hex\t_hexhook.cpp

// 

//

#include "t_hexhook.h"

#include <f32pluginutils.h>

#include "hex.h"

_LIT(KHexPluginName, "This is a test plugin which converts binary data to hex");

/**

Leaving New function for the plugin

@internalComponent

*/

CTestHexHook* CTestHexHook::NewL()

	{

	return new(ELeave) CTestHexHook;

	}

/**

Constructor for the plugin

@internalComponent

*/

CTestHexHook::CTestHexHook()

	{

	}

/**

The destructor for the test hex plugin hook. 

@internalComponent

*/

CTestHexHook::~CTestHexHook()

	{

	iFs.Close();

	}

/**

Initialise the hex plugin.

@internalComponent

*/

void CTestHexHook::InitialiseL()

	{

	User::LeaveIfError(RegisterIntercept(EFsFileOpen,			EPreIntercept));

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

//	User::LeaveIfError(RegisterIntercept(EFsFileWrite,			EPreIntercept));

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

	}

/**

@internalComponent

*/

TInt CTestHexHook::DoRequestL(TFsPluginRequest& aRequest)

	{

	TInt err = KErrNotSupported;

	TInt function = aRequest.Function();

	iDrvNumber = aRequest.DriveNumber();

	switch(function)

		{

		case EFsFileOpen:

			err = HexFileOpen(aRequest);

			break;

		case EFsFileRead:

			// Post intercept does nothing except prove that it is possible and that no deadlock occurs.

			// plugin always calls FileRead() when receiving a EFsFileRead, and so the mesage gets completed

			// by the plugin and has to be post intercepted by the plugin (if registered to post-intercept the request) 

			// and any plugins above it.

			if (!(aRequest.IsPostOperation()))

				err = HexFileRead(aRequest);

			break;

		default:

			break;

		}

	return err;

	}

/**

@internalComponent

*/

TInt CTestHexHook::HexFileOpen(TFsPluginRequest& aRequest)

	{

	TFileName fileName;

//	TInt driveNumber = aRequest.DriveNumber();

	TInt err = GetName(&aRequest, fileName);

	if(err != KErrNone)

		return(err);

//	err = ScanFile(fileName);

	return err;

	}

/**

@internalComponent

*/

TInt CTestHexHook::HexFileRead(TFsPluginRequest& aRequest)

	{

	TFileName fileName;

//	TInt driveNumber = aRequest.DriveNumber();

	TInt r = GetName(&aRequest, fileName);

	if(r != KErrNone)

		return(r);

	TInt len, pos;

	r = GetFileAccessInfo(&aRequest, len, pos);

	if (r != KErrNone)

		return r;

	// if length is ODD, then it can't be hex

	if (len & 0x01)

		return KErrCorrupt;

	TInt offset = 0;

	while(len > 0)

		{

		TInt readLen = Min(len<<1, iHexBuf.MaxLength());

		// read from file

		TPtr8 ptrHex((TUint8*) iHexBuf.Ptr(), readLen, readLen);

		r = FileRead(aRequest, ptrHex, pos<<1);

		if (r != KErrNone)

			return r;

		readLen = ptrHex.Length();

		if (readLen == 0)

			return KErrCompletion;

		TInt binLen = readLen>>1;

		TPtr8 ptrBin((TUint8*) iBinBuf.Ptr(), binLen, binLen);

		DeHex(ptrHex, ptrBin);

		// write back to client (may be an app or another plugin)

		r = ClientWrite(aRequest, ptrBin, offset);

		offset+= binLen;

		len-= binLen;

		pos+= readLen;

		}

	return KErrCompletion;

	}

/**

@internalComponent

*/

TInt CTestHexHook::HexPluginName(TDes& aName)

	{

	aName = KHexPluginName;

	return KErrNone;

	}

//factory functions

class CHexHookFactory : public CFsPluginFactory

	{

public:

	CHexHookFactory();

	virtual TInt Install();			

	virtual CFsPlugin* NewPluginL();

	virtual CFsPlugin* NewPluginConnL();

	virtual TInt UniquePosition();

	};

/**

Constructor for the plugin factory

@internalComponent

*/

CHexHookFactory::CHexHookFactory()

	{

	}

/**

Install function for the plugin factory

@internalComponent

*/

TInt CHexHookFactory::Install()

	{

	iSupportedDrives = KPluginAutoAttach;

	_LIT(KHexHookName,"HexHook");

	return(SetName(&KHexHookName));

	}

/**

@internalComponent

*/

TInt CHexHookFactory::UniquePosition()

	{

	return(0x4EC);

	}

/**

Plugin factory function

@internalComponent

*/

CFsPlugin* CHexHookFactory::NewPluginL()

	{

	return CTestHexHook::NewL();

	}

/**

Plugin factory function

@internalComponent

*/

CFsPlugin* CHexHookFactory::NewPluginConnL()

	{

	return CTestHexHook::NewL();

	}

/**

Create a new Plugin

@internalComponent

*/

extern "C" {

EXPORT_C CFsPluginFactory* CreateFileSystem()

	{

	return(new CHexHookFactory());

	}

}