// 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\encrypt\t_enchook.cpp

 // 

 //

 #include "t_enchook.h"

 #include <f32pluginutils.h>

 #include "encrypt.h"

 _LIT(KEncryptionPluginName, "This is a test encryption plugin");

 /**

 Leaving New function for the plugin

 @internalComponent

 */

 CTestEncryptionHook* CTestEncryptionHook::NewL()

 	{

 	return new(ELeave) CTestEncryptionHook;

 	}

 /**

 Constructor for the plugin

 @internalComponent

 */

 CTestEncryptionHook::CTestEncryptionHook()

 	{

 	}

 /**

 The destructor for the test encryptplugin hook.  This would

 not be a part of a normal encryption plugin implementation as

 normal encryption plugins cannot be unloaded - it must be 

 provided in the test encryption plugin server so that it can

 be tested with the F32 test suite.

 @internalComponent

 */

 CTestEncryptionHook::~CTestEncryptionHook()

 	{

 	iFs.Close();

 	}

 /**

 Initialise the encryption plugin.

 @internalComponent

 */

 void CTestEncryptionHook::InitialiseL()

 	{

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

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

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

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

 	}

 /**

 @internalComponent

 */

 TInt CTestEncryptionHook::DoRequestL(TFsPluginRequest& aRequest)

 	{

 	TInt err = KErrNotSupported;

 	TInt function = aRequest.Function();

 	iDrvNumber = aRequest.DriveNumber();

 	switch(function)

 		{

 		case EFsFileOpen:

 			err = EncFileOpen(aRequest);

 			break;

 		case EFsFileRead:

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

 			// In fact as this plugin always calls FileRead() when receiving a EFsFileRead, the file 

 			// server should never call this plugin in post-intercept mode as deadlock would result).

 			if (aRequest.IsPostOperation())

 				ASSERT(0);

 			else

 				err = EncFileRead(aRequest);

 			break;

 		default:

 			break;

 		}

 	return err;

 	}

 /**

 @internalComponent

 */

 TInt CTestEncryptionHook::EncFileOpen(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 CTestEncryptionHook::EncFileRead(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;

 	TInt offset = 0;

 	while(len > 0)

 		{

 		TInt readLen = Min(len, iFileBuf.MaxLength());

 		// read from file

 		TPtr8 ptr((TUint8*) iFileBuf.Ptr(), readLen, readLen);

 		r = FileRead(aRequest, ptr, pos);

 		if (r != KErrNone)

 			return r;

 		readLen = ptr.Length();

 		if (readLen == 0)

 			return KErrCompletion;

 		Decrypt(ptr);

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

 		r = ClientWrite(aRequest, ptr, offset);

 		offset+= readLen;

 		len-= readLen;

 		pos+= readLen;

 		}

 	return KErrCompletion;

 	}

 /**

 @internalComponent

 */

 TInt CTestEncryptionHook::EncryptionPluginName(TDes& aName)

 	{

 	aName = KEncryptionPluginName;

 	return KErrNone;

 	}

 //factory functions

 class CEncHookFactory : public CFsPluginFactory

 	{

 public:

 	CEncHookFactory();

 	virtual TInt Install();			

 	virtual CFsPlugin* NewPluginL();

 	virtual CFsPlugin* NewPluginConnL();

 	virtual TInt UniquePosition();

 	};

 /**

 Constructor for the plugin factory

 @internalComponent

 */

 CEncHookFactory::CEncHookFactory()

 	{

 	}

 /**

 Install function for the plugin factory

 @internalComponent

 */

 TInt CEncHookFactory::Install()

 	{

 	iSupportedDrives = KPluginAutoAttach;

 	_LIT(KEncHookName,"EncHook");

 	return(SetName(&KEncHookName));

 	}

 /**

 @internalComponent

 */

 TInt CEncHookFactory::UniquePosition()

 	{

 	return(0x4CC);

 	}

 /**

 Plugin factory function

 @internalComponent

 */

 CFsPlugin* CEncHookFactory::NewPluginL()

 	{

 	return CTestEncryptionHook::NewL();

 	}

 /**

 Plugin factory function

 @internalComponent

 */

 CFsPlugin* CEncHookFactory::NewPluginConnL()

 	{

 	return CTestEncryptionHook::NewL();

 	}

 /**

 Create a new Plugin

 @internalComponent

 */

 extern "C" {

 EXPORT_C CFsPluginFactory* CreateFileSystem()

 	{

 	return(new CEncHookFactory());

 	}

 }