Symaptic: os/kernelhwsrv/kerneltest/f32test/plugins/version_2/src/modifier

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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include "modifier_plugin.h"

    17 #include "plugincommon.h"

    18 #include <f32pluginutils.h>

    20 /**

    21 Leaving New function for the plugin

    22 @internalComponent

    23 */

    24 CModifierPlugin* CModifierPlugin::NewL()

    25 	{

    26 	CModifierPlugin* self = new(ELeave) CModifierPlugin;

    27     CleanupStack::PushL(self);

    28     self->ConstructL();

    29     CleanupStack::Pop();

    30 	return self;

    31 	}

    34 /**

    35 Constructor for the plugin

    36 @internalComponent

    37 */

    38 CModifierPlugin::CModifierPlugin() : iInterceptsEnabled(EFalse),

    39 									 iLogging(ETrue)

    40 	{

    41 	}

    44 void CModifierPlugin::ConstructL()

    45 	{

    46 	}

    48 /**

    49 The destructor for the plugin

    50 @internalComponent

    51 */

    52 CModifierPlugin::~CModifierPlugin()

    53 	{

    54 	}

    56 /**

    57 Initialise the plugin.

    58 @internalComponent

    59 */

    60 void CModifierPlugin::InitialiseL()

    61 	{

    62 	EnableInterceptsL();

    63 	}

    65 /**

    66 Enable the plugin's intercepts.

    67 @internalComponent

    68 */

    69 void CModifierPlugin::EnableInterceptsL()

    70 	{

    71 	if (iInterceptsEnabled) return;

    73     User::LeaveIfError(RegisterIntercept(EFsFileRead,   		EPreIntercept));

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

    75 	User::LeaveIfError(RegisterIntercept(EFsFileRename,		 	EPreIntercept));

    76 	User::LeaveIfError(RegisterIntercept(EFsFileCreate,		 	EPreIntercept));

    77 	User::LeaveIfError(RegisterIntercept(EFsFileSize,  		 	EPreIntercept));

    78 	User::LeaveIfError(RegisterIntercept(EFsFileSetSize,	 	EPreIntercept));

    79 	User::LeaveIfError(RegisterIntercept(EFsFileLock,  			EPreIntercept));

    80 	User::LeaveIfError(RegisterIntercept(EFsFileUnLock,  		EPreIntercept));

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

    82 	User::LeaveIfError(RegisterIntercept(EFsFileReplace,		EPreIntercept));

    83 	User::LeaveIfError(RegisterIntercept(EFsReadFileSection,	EPreIntercept));

    84 	User::LeaveIfError(RegisterIntercept(EFsDirReadOne,  		EPreIntercept));

    85 	User::LeaveIfError(RegisterIntercept(EFsDirReadPacked,		EPreIntercept));

    86 	User::LeaveIfError(RegisterIntercept(EFsFileSubClose,       EPreIntercept));

    87 	User::LeaveIfError(RegisterIntercept(EFsDirOpen,			EPreIntercept));

    88 	User::LeaveIfError(RegisterIntercept(EFsFileTemp,			EPreIntercept));

    89 	User::LeaveIfError(RegisterIntercept(EFsDelete,				EPreIntercept));

    90 	User::LeaveIfError(RegisterIntercept(EFsReplace,			EPreIntercept));

    91 	User::LeaveIfError(RegisterIntercept(EFsRename,				EPreIntercept));

    92 	User::LeaveIfError(RegisterIntercept(EFsEntry,				EPreIntercept));

    93 	User::LeaveIfError(RegisterIntercept(EFsSetEntry,			EPreIntercept));

    94 	User::LeaveIfError(RegisterIntercept(EFsFileSeek,			EPreIntercept));

    95 	User::LeaveIfError(RegisterIntercept(EFsPluginDoControl,	EPreIntercept));

    96 	User::LeaveIfError(RegisterIntercept(EFsPluginDoRequest,	EPreIntercept));

    97 	User::LeaveIfError(RegisterIntercept(EFsVolume,				EPreIntercept));

   100     _LOG(_L("Modifier Plugin: Enabled intercepts."));

   102     iInterceptsEnabled = ETrue;

   103 	}

   105 /**

   106 Disable the plugin's intercepts.

   107 @internalComponent

   108 */

   109 void CModifierPlugin::DisableInterceptsL()

   110 	{

   111 	if (!iInterceptsEnabled) return;

   113     User::LeaveIfError(UnregisterIntercept(EFsFileRead,    		EPreIntercept));

   114     User::LeaveIfError(UnregisterIntercept(EFsFileWrite,   		EPreIntercept));

   115     User::LeaveIfError(UnregisterIntercept(EFsFileRename,  		EPreIntercept));

   116 	User::LeaveIfError(UnregisterIntercept(EFsFileCreate,  		EPreIntercept));

   117 	User::LeaveIfError(UnregisterIntercept(EFsFileSize,    		EPreIntercept));

   118 	User::LeaveIfError(UnregisterIntercept(EFsFileSetSize, 		EPreIntercept));

   119 	User::LeaveIfError(UnregisterIntercept(EFsFileLock,    		EPreIntercept));

   120 	User::LeaveIfError(UnregisterIntercept(EFsFileUnLock,  		EPreIntercept));

   121 	User::LeaveIfError(UnregisterIntercept(EFsFileOpen,        	EPreIntercept));

   122 	User::LeaveIfError(UnregisterIntercept(EFsFileReplace,      EPreIntercept));

   123 	User::LeaveIfError(UnregisterIntercept(EFsReadFileSection,  EPreIntercept));

   124 	User::LeaveIfError(UnregisterIntercept(EFsDirReadOne,  		EPreIntercept));

   125 	User::LeaveIfError(UnregisterIntercept(EFsDirReadPacked,	EPreIntercept));

   126 	User::LeaveIfError(UnregisterIntercept(EFsFileSubClose,     EPreIntercept));

   127 	User::LeaveIfError(UnregisterIntercept(EFsDirOpen,			EPreIntercept));

   128 	User::LeaveIfError(UnregisterIntercept(EFsFileTemp,			EPreIntercept));

   129 	User::LeaveIfError(UnregisterIntercept(EFsDelete,			EPreIntercept));

   130 	User::LeaveIfError(UnregisterIntercept(EFsReplace,			EPreIntercept));

   131 	User::LeaveIfError(UnregisterIntercept(EFsRename,			EPreIntercept));

   132 	User::LeaveIfError(UnregisterIntercept(EFsEntry,			EPreIntercept));

   133 	User::LeaveIfError(UnregisterIntercept(EFsSetEntry,			EPreIntercept));

   134 	User::LeaveIfError(UnregisterIntercept(EFsFileSeek,			EPreIntercept));

   135 	User::LeaveIfError(UnregisterIntercept(EFsVolume,			EPreIntercept));

   137     _LOG(_L("Modifier Plugin: Disabled intercepts."));

   139     iInterceptsEnabled = EFalse;

   140 	}

   142 /**

   143 Handle requests

   144 @internalComponent

   145 */

   146 TInt CModifierPlugin::DoRequestL(TFsPluginRequest& aRequest)

   147 	{

   148 	iLastError = KErrNone;

   149 	iLineNumber = __LINE__;

   151 	TInt err = KErrNone;

   153 	TInt function = aRequest.Function();

   155 	if(aRequest.IsPostOperation())

   156 		{

   157 		_LOG2(_L("CModifierPlugin::DoRequestL for Function %d in Post-Interception"),function);

   158 		}

   159 	else

   160 		{

   161 		_LOG2(_L("CModifierPlugin::DoRequestL for Function %d in Pre-Interception"),function);

   162 		}

   164 	switch(function)

   165 		{

   166 		case EFsFileRead:

   167 			TRAP(err, FsFileReadL(aRequest));

   168 			break;

   170 		case EFsFileWrite:

   171 			TRAP(err, FsFileWriteL(aRequest));

   172 			break;

   174 		case EFsFileRename:

   175 			TRAP(err, FsFileRenameL(aRequest));

   176 			break;

   178 		case EFsFileCreate:

   179 			TRAP(err, FsFileCreateL(aRequest));

   180 			break;

   182 		case EFsFileSize:

   183 			TRAP(err, FsFileSizeL(aRequest));

   184 			break;

   186 		case EFsFileSetSize:

   187 			TRAP(err, FsFileSetSizeL(aRequest));

   188 			break;

   190 		case EFsFileLock:

   191 			TRAP(err, FsFileLockL(aRequest));

   192 			break;

   194 		case EFsFileUnLock:

   195 			TRAP(err, FsFileUnLockL(aRequest));

   196 			break;

   198 		case EFsFileSeek:

   199 			TRAP(err, FsFileSeekL(aRequest));

   200 			break;

   202 		case EFsDirReadOne:

   203 			TRAP(err,FsDirReadOneL(aRequest));

   204 			break;

   206 		case EFsDirReadPacked:

   207 			TRAP(err,FsDirReadPackedL(aRequest));

   208 			break;

   210 		case EFsFileOpen:

   211 			TRAP(err, FsFileOpenL(aRequest));

   212 			break;

   214 		case EFsFileReplace:

   215 			TRAP(err, FsFileReplaceL(aRequest));

   216 			break;

   218 		case EFsReadFileSection:

   219 			TRAP(err, FsReadFileSectionL(aRequest));

   220 			break;

   222 		case EFsFileSubClose:

   223 			TRAP(err, FsFileSubCloseL(aRequest));

   224 			break;

   226 		case EFsDirOpen:

   227 			TRAP(err, FsDirOpenL(aRequest));

   228 			break;

   230 		case EFsFileTemp:

   231 			TRAP(err, FsFileTempL(aRequest));

   232 			break;

   234 		case EFsDelete:

   235 			TRAP(err, FsDeleteL(aRequest));

   236 			break;

   238 		case EFsReplace:

   239 			TRAP(err, FsReplaceL(aRequest));

   240 			break;

   242 		case EFsRename:

   243 			TRAP(err, FsRenameL(aRequest));

   244 			break;

   246 		case EFsEntry:

   247 			TRAP(err, FsEntryL(aRequest));

   248 			break;

   250 		case EFsSetEntry:

   251 			TRAP(err, FsSetEntryL(aRequest));

   252 			break;

   254 		case EFsVolume:

   255 			TRAP(err, FsVolumeL(aRequest));

   256 			break;

   258 		default:

   259 			break;

   260 		}

   262 	return err;

   263 	}

   266 /**

   267 @internalComponent

   268 */

   269 void CModifierPlugin::FsFileUnLockL(TFsPluginRequest& aRequest)

   270 	{

   271 	TInt length = 0;

   272 	TInt64 pos = 0;

   273 	TFileName filename;

   274 	TParse parse;

   276 	TInt err = aRequest.FileName(filename);

   277 	iLastError = err;

   278 	iLineNumber = __LINE__;

   279 	if(err!=KErrNone)

   280 		User::Leave(err); //trapped in DoRequestL

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

   283 	iLastError = err;

   284 	iLineNumber = __LINE__;

   285 	if(err!=KErrNone)

   286 		User::Leave(err); //trapped in DoRequestL

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

   289 	iLastError = err;

   290 	iLineNumber = __LINE__;

   291 	if(err!=KErrNone)

   292 		User::Leave(err); //trapped in DoRequestL

   294     parse.Set(filename, NULL, NULL);

   295 	TPtrC extension(parse.Ext());

   297 	_LOG4(_L("CModifierPlugin::FsFileUnLockL, file: %S, pos: %d, length: %d"), &filename, pos, length);

   299 	if (aRequest.IsPostOperation())

   300 		{

   301 		_LOG(_L("CModifierPlugin::FsFileUnLockL, post intercept"));

   302 		}

   303 	else

   304 		{

   305 		_LOG(_L("CModifierPlugin::FsFileUnLockL, pre intercept"));

   306 		if(extension.CompareF(_L(".unlock")) == 0)

   307 			{

   308 			RFilePlugin fileplugin(aRequest);

   309 			err = fileplugin.AdoptFromClient();

   310 			iLastError = err;

   311 			iLineNumber = __LINE__;

   312 			if(err!=KErrNone)

   313 				User::Leave(err); //trapped in DoRequestL

   315 			err = fileplugin.UnLock(pos, length);

   316 			iLastError = err;

   317 			iLineNumber = __LINE__;

   318 			if(err!=KErrNone)

   319 				User::Leave(err); //trapped in DoRequestL

   321 			fileplugin.Close();

   323 			User::Leave(KErrCompletion);

   324 			}

   325 		}

   326 	}

   328 /**

   329 @internalComponent

   330 */

   331 void CModifierPlugin::FsFileLockL(TFsPluginRequest& aRequest)

   332 	{

   333 	TInt length = 0;

   334 	TInt64 pos = 0;

   335 	TFileName filename;

   336 	TParse parse;

   338 	TInt err = aRequest.FileName(filename);

   339 	iLastError = err;

   340 	iLineNumber = __LINE__;

   341 	if(err!=KErrNone)

   342 		User::Leave(err); //trapped in DoRequestL

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

   345 	iLastError = err;

   346 	iLineNumber = __LINE__;

   347 	if(err!=KErrNone)

   348 		User::Leave(err); //trapped in DoRequestL

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

   351 	iLastError = err;

   352 	iLineNumber = __LINE__;

   353 	if(err!=KErrNone)

   354 		User::Leave(err); //trapped in DoRequestL

   356     parse.Set(filename, NULL, NULL);

   357 	TPtrC extension(parse.Ext());

   359 	_LOG4(_L("CModifierPlugin::FsFileLockL, file: %S, pos: %d, length: %d"), &filename, pos, length);

   361 	if (aRequest.IsPostOperation())

   362 		{

   363 		_LOG(_L("CModifierPlugin::FsFileLockL, post intercept"));

   365 		// Request read from post interception

   366 		if (extension.CompareF(_L(".lockread")) == 0)

   367 			{

   368 			length = 10;

   369 			HBufC8* tempBuf = HBufC8::NewMaxLC(length);

   370 			TPtr8 tempBufPtr((TUint8 *)tempBuf->Des().Ptr(), length, length);

   371 			_LOG(_L("CModifierPlugin::FsFileLockL , calling FileRead in post intercept"));

   372 			RFilePlugin fileplugin(aRequest);

   373 			TInt err = fileplugin.AdoptFromClient();

   374 			_LOG2(_L("CModifierPlugin::FsFileLockL, Adopt returned %d"), err);

   375 			iLastError = err;

   376 			iLineNumber = __LINE__;

   377 			if(err!=KErrNone)

   378 				User::Leave(err); //trapped in DoRequestL

   380 			err = fileplugin.Read(pos, tempBufPtr, length);

   381 			_LOG2(_L("CModifierPlugin::FsFileLockL, FileRead returned %d"), err);

   382 			iLastError = err;

   383 			iLineNumber = __LINE__;

   384 			if(err!=KErrNone)

   385 				User::Leave(err); //trapped in DoRequestL

   387 			fileplugin.Close();

   388 			CleanupStack::PopAndDestroy();

   389 			}

   391 		// Request close from post interception

   392 		if(extension.CompareF(_L(".lockclose")) == 0)

   393 			{

   394 			_LOG(_L("CModifierPlugin::FsFileLockL, calling Close in post intercept "));

   396 			RFilePlugin fileplugin(aRequest);

   397 		    TInt err = fileplugin.AdoptFromClient();

   398 			_LOG2(_L("CModifierPlugin::FsFileLockL ,Open %d"), err);

   399 			iLastError = err;

   400 			iLineNumber = __LINE__;

   401 			if(err!=KErrNone)

   402 				User::Leave(err); //trapped in DoRequestL

   403 			fileplugin.Close();

   404 			_LOG(_L("CModifierPlugin::FsFileLockL, Close"));

   405 			//Try to close twice?

   406 			fileplugin.Close();

   407 			_LOG(_L("CModifierPlugin::FsFileLockL, Close"));

   408 			}

   410 		}

   411 	else

   412 		{

   413 		_LOG(_L("CModifierPlugin::FsFileLockL, pre intercept"));

   414 		if((extension.CompareF(_L(".lock")) == 0)

   415 			|| (extension.CompareF(_L(".lockclose")) == 0)

   416 			    || (extension.CompareF(_L(".lockread")) == 0) )

   417 			{

   418 			RFilePlugin fileplugin(aRequest);

   419 			TInt err = fileplugin.AdoptFromClient();

   420 			iLastError = err;

   421 			iLineNumber = __LINE__;

   422 			if(err!=KErrNone)

   423 				User::Leave(err); //trapped in DoRequestL

   425 			err = fileplugin.Lock(0,2);

   426 			iLastError = err;

   427 			iLineNumber = __LINE__;

   428 			if(err!=KErrNone)

   429 				User::Leave(err); //trapped in DoRequestL

   431 			fileplugin.Close();

   433 			User::Leave(KErrCompletion);

   434 			}

   435 		}

   436 	}

   438 /**

   439 @internalComponent

   440 */

   441 void CModifierPlugin::FsFileSeekL(TFsPluginRequest& aRequest)

   442 	{

   443 	TFileName filename;

   444 	TParse parse;

   446 	TInt err = aRequest.FileName(filename);

   447 	iLastError = err;

   448 	iLineNumber = __LINE__;

   449 	if(err!=KErrNone)

   450 		User::Leave(err); //trapped in DoRequestL

   452     parse.Set(filename, NULL, NULL);

   453 	TPtrC extension(parse.Ext());

   455 	_LOG2(_L("CModifierPlugin::FsFileSeekL, file: %S"), &filename);

   457 	if (aRequest.IsPostOperation())

   458 		{

   459 		_LOG(_L("CModifierPlugin::FsFileSeekL, post intercept"));

   460 		}

   461 	else

   462 		{

   463 		_LOG(_L("CModifierPlugin::FsFileSeekL, pre intercept"));

   464 		if(extension.CompareF(_L(".seek")) == 0)

   465 			{

   466 			RFilePlugin fileplugin(aRequest);

   467 			TInt err = fileplugin.AdoptFromClient();

   468 			iLastError = err;

   469 			iLineNumber = __LINE__;

   470 			if(err!=KErrNone)

   471 				User::Leave(err); //trapped in DoRequestL

   473 			TInt64 pos;

   474 			TSeek mode;

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

   476 			iLastError = err;

   477 			iLineNumber = __LINE__;

   478 			if(err!=KErrNone)

   479 				User::Leave(err); //trapped in DoRequestL

   481 			err = aRequest.Read(TFsPluginRequest::EMode, (TUint&)mode);

   482 			iLastError = err;

   483 			iLineNumber = __LINE__;

   484 			if(err!=KErrNone)

   485 				User::Leave(err); //trapped in DoRequestL

   487 			err = fileplugin.Seek(mode,pos);

   488 			iLastError = err;

   489 			iLineNumber = __LINE__;

   490 			if(err!=KErrNone)

   491 				User::Leave(err); //trapped in DoRequestL

   493 			//STF: When we add TInt64 write, should also add TInt write also...

   494 			TPtrC8 p((TUint8*)&pos,sizeof(TInt));

   495 			err = aRequest.Write(TFsPluginRequest::ENewPosition, p);

   496 			iLastError = err;

   497 			iLineNumber = __LINE__;

   498 			if(err!=KErrNone)

   499 				User::Leave(err); //trapped in DoRequestL

   501 			fileplugin.Close();

   502 			}

   503 		}

   504 	}

   506 /**

   507 @internalComponent

   508 */

   509 void CModifierPlugin::FsFileSizeL(TFsPluginRequest& aRequest)

   510 	{

   511 	TFileName filename;

   512 	TParse parse;

   514 	TInt err = aRequest.FileName(filename);

   515 	iLastError = err;

   516 	iLineNumber = __LINE__;

   517 	if(err!=KErrNone)

   518 		User::Leave(err); //trapped in DoRequestL

   520     parse.Set(filename, NULL, NULL);

   521 	TPtrC extension(parse.Ext());

   523 	_LOG2(_L("CModifierPlugin::FsFileSizeL, file: %S"), &filename);

   525 	if (aRequest.IsPostOperation())

   526 		{

   527 		_LOG(_L("CModifierPlugin::FsFileSizeL, post intercept"));

   528 		}

   529 	else

   530 		{

   531 		_LOG(_L("CModifierPlugin::FsFileSizeL, pre intercept"));

   532 		if(extension.CompareF(_L(".size")) == 0)

   533 			{

   534 			_LOG(_L("CModifierPlugin::FsFileSizeL"));

   536 			RFilePlugin fileplugin(aRequest);

   537 			TInt err = fileplugin.AdoptFromClient();

   538 			iLastError = err;

   539 			iLineNumber = __LINE__;

   540 			if(err!=KErrNone)

   541 				User::Leave(err); //trapped in DoRequestL

   543 			TInt64 size=0;

   544 			err = fileplugin.Size(size);

   545 			iLastError = err;

   546 			iLineNumber = __LINE__;

   547 			if(err!=KErrNone)

   548 				User::Leave(err); //trapped in DoRequestL

   550 			TInt sizeLow = I64LOW(size);	//STF: Need 64-bit write for size?

   551 			TPckgBuf<TInt> sizeBuf(sizeLow);

   552 			err = aRequest.Write(TFsPluginRequest::ESize, sizeBuf);

   553 			iLastError = err;

   554 			iLineNumber = __LINE__;

   555 			if(err!=KErrNone)

   556 				User::Leave(err); //trapped in DoRequestL

   558 			fileplugin.Close();

   560 			// request processed by plug-in

   561 			User::Leave(KErrCompletion);

   562 			}

   563 		}

   564 	}

   566 /**

   567 @internalComponent

   568 */

   569 void CModifierPlugin::FsFileSetSizeL(TFsPluginRequest& aRequest)

   570 	{

   571 	TFileName filename;

   572 	TParse parse;

   574 	TInt err = aRequest.FileName(filename);

   575 	iLastError = err;

   576 	iLineNumber = __LINE__;

   577 	if(err!=KErrNone)

   578 		User::Leave(err); //trapped in DoRequestL

   580     parse.Set(filename, NULL, NULL);

   582 	_LOG2(_L("CModifierPlugin::FsFileSetSizeL, file: %S"), &filename);

   584 	if (aRequest.IsPostOperation())

   585 		{

   586 		_LOG(_L("CModifierPlugin::FsFileSetSizeL, post intercept"));

   587 		}

   588 	else

   589 		{

   590 		RFilePlugin fileplugin(aRequest);

   591 		TInt err = fileplugin.AdoptFromClient();

   592 		iLastError = err;

   593 		iLineNumber = __LINE__;

   594 		if(err!=KErrNone)

   595 			User::Leave(err); //trapped in DoRequestL

   597 		_LOG(_L("CModifierPlugin::FsFileSetSizeL, pre intercept"));

   599 		TInt size = 0;

   600 		err = aRequest.Read(TFsPluginRequest::ESize, size);

   601 		iLastError = err;

   602 		iLineNumber = __LINE__;

   603 		if(err!=KErrNone)

   604 			User::Leave(err); //trapped in DoRequestL

   606 		err = fileplugin.SetSize(size);

   607 		iLastError = err;

   608 		iLineNumber = __LINE__;

   609 		if(err!=KErrNone)

   610 			User::Leave(err); //trapped in DoRequestL

   612 		fileplugin.Close();

   614 		// request processed by plug-in

   615 		User::Leave(KErrCompletion);

   616 		}

   617 	}

   619 /**

   620 @internalComponent

   621 */

   622 void CModifierPlugin::FsFileReadL(TFsPluginRequest& aRequest)

   623 	{

   624 	TInt length = 0;

   625 	TInt64 pos = 0;

   626 	TFileName filename;

   627 	TParse parse;

   629 	TInt err = aRequest.FileName(filename);

   630 	iLastError = err;

   631 	iLineNumber = __LINE__;

   632 	if(err!=KErrNone)

   633 		User::Leave(err); //trapped in DoRequestL

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

   636 	iLastError = err;

   637 	iLineNumber = __LINE__;

   638 	if(err!=KErrNone)

   639 		User::Leave(err); //trapped in DoRequestL

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

   642 	iLastError = err;

   643 	iLineNumber = __LINE__;

   644 	if(err!=KErrNone)

   645 		User::Leave(err); //trapped in DoRequestL

   647     parse.Set(filename, NULL, NULL);

   648 	TPtrC extension(parse.Ext());

   650 	_LOG4(_L("CModifierPlugin::FsFileReadL, file: %S, pos: %d, length: %d"), &filename, pos, length);

   652 	if (aRequest.IsPostOperation())

   653 		{

   654 		_LOG(_L("CModifierPlugin::FsFileReadL, post intercept"));

   655 		}

   656 	else

   657 		{

   658 		_LOG(_L("CModifierPlugin::FsFileReadL, pre intercept"));

   659 		if (extension.CompareF(_L(".tst")) == 0)

   660 			{

   662 			HBufC8* tempBuf = HBufC8::NewMaxLC(length);

   663 			TPtr8 tempBufPtr((TUint8 *)tempBuf->Des().Ptr(), length, length);

   665 			_LOG(_L("CModifierPlugin::FsFileReadL, calling FileRead"));

   667 			RFilePlugin fileplugin(aRequest);

   668 			TInt err = fileplugin.AdoptFromClient();

   669 			iLastError = err;

   670 			iLineNumber = __LINE__;

   671 			if(err!=KErrNone)

   672 				User::Leave(err); //trapped in DoRequestL

   674 			err = fileplugin.Read(pos, tempBufPtr, length);

   675 			_LOG2(_L("CModifierPlugin::FsFileReadL, FileRead returned %d"), err);

   676 			iLastError = err;

   677 			iLineNumber = __LINE__;

   678 			if(err!=KErrNone)

   679 				User::Leave(err); //trapped in DoRequestL

   681 			err = aRequest.Write(TFsPluginRequest::EData, tempBufPtr);

   682 			_LOG2(_L("CModifierPlugin::FsFileReadL, ClientWrite returned %d"), err);

   683 			iLastError = err;

   684 			iLineNumber = __LINE__;

   685 			if(err!=KErrNone)

   686 				User::Leave(err); //trapped in DoRequestL

   688 			fileplugin.Close();

   690 			CleanupStack::PopAndDestroy(); //tempBuf

   692 			// request processed by plug-in

   693 			User::Leave(KErrCompletion);

   694 			}

   696 		// Intercepting a Read(has handle) and performing a ReadFileSection (lacks handle) instead

   697 		if (extension.CompareF(_L(".readfile")) == 0)

   698 			{

   699 			HBufC8* tempBuf = HBufC8::NewMaxLC(length);

   700 			TPtr8 tempBufPtr((TUint8 *)tempBuf->Des().Ptr(), length, length);

   702 			_LOG(_L("CModifierPlugin::FileRead, calling FsReadFileSection "));

   704 			RFsPlugin fsplugin(aRequest);

   705 			TInt err = fsplugin.Connect();

   706 			iLastError = err;

   707 			iLineNumber = __LINE__;

   708 			if(err!=KErrNone)

   709 				User::Leave(err); //trapped in DoRequestL

   711 			err = fsplugin.ReadFileSection(filename, pos, tempBufPtr, length);

   712 			_LOG2(_L("CModifierPlugin::FileRead, FileRead returned %d"), err);

   713 			iLastError = err;

   714 			iLineNumber = __LINE__;

   715 			if(err!=KErrNone)

   716 				User::Leave(err); //trapped in DoRequestL

   719 			err = aRequest.Write(TFsPluginRequest::EData, tempBufPtr);

   720 			_LOG2(_L("CModifierPlugin::FileRead, ClientWrite returned %d"), err);

   721 			iLastError = err;

   722 			iLineNumber = __LINE__;

   723 			if(err!=KErrNone)

   724 				User::Leave(err); //trapped in DoRequestL

   726 			fsplugin.Close();

   727 			CleanupStack::PopAndDestroy();

   729 			// request processed by plug-in

   730 			User::Leave(KErrCompletion);

   731 			}

   733 		}

   734 	}

   737 /**

   738 @internalComponent

   739 */

   740 void CModifierPlugin::FsFileWriteL(TFsPluginRequest& aRequest)

   741 	{

   742 	TInt length = 0;

   743 	TInt64 pos = 0;

   744 	TFileName filename;

   745 	TParse parse;

   747 	TBuf<256> testfilename1;

   748 	TBuf<256> testfilename2;

   750 	//setting up test files

   751 	testfilename1.Append(iDriveToTest);

   752 	testfilename1.Append(_L(":\\Data\\test.txt"));

   754 	testfilename2.Append(iDriveToTest);

   755 	testfilename2.Append(_L(":\\Data\\createcreate3.txt"));

   757 	TInt err = aRequest.FileName(filename);

   758 	iLastError = err;

   759 	iLineNumber = __LINE__;

   760 	if(err!=KErrNone)

   761 		User::Leave(err); //trapped in DoRequestL

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

   764 	iLastError = err;

   765 	iLineNumber = __LINE__;

   766 	if(err!=KErrNone)

   767 		User::Leave(err); //trapped in DoRequestL

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

   770 	iLastError = err;

   771 	iLineNumber = __LINE__;

   772 	if(err!=KErrNone)

   773 		User::Leave(err); //trapped in DoRequestL

   775     parse.Set(filename, NULL, NULL);

   776 	TPtrC extension(parse.Ext());

   778 	_LOG4(_L("CModifierPlugin::FsFileWriteL, file: %S, pos: %d, length: %d"), &filename, pos, length);

   780 	if (aRequest.IsPostOperation())

   781 		{

   782 		_LOG(_L("CModifierPlugin::FsFileWriteL, post intercept"));

   783 		}

   784 	else

   785 		{

   786 		_LOG(_L("CModifierPlugin::FsFileWriteL, pre intercept"));

   788 		if (extension.CompareF(_L(".tst")) == 0)

   789 			{

   790 			HBufC8* tempBuf = HBufC8::NewMaxLC(length);

   791 			TPtr8 tempBufPtr((TUint8 *)tempBuf->Des().Ptr(), length, length);

   793 			TInt err = aRequest.Read(TFsPluginRequest::EData, tempBufPtr);

   794 			_LOG2(_L("CModifierPlugin::FsFileWriteL, ClientRead returned %d"), err);

   795 			iLastError = err;

   796 			iLineNumber = __LINE__;

   797 			if(err!=KErrNone)

   798 				User::Leave(err); //trapped in DoRequestL

   800 			RFilePlugin fileplugin(aRequest);

   801 			err = fileplugin.AdoptFromClient();

   802 			iLastError = err;

   803 			iLineNumber = __LINE__;

   804 			if(err!=KErrNone)

   805 				User::Leave(err); //trapped in DoRequestL

   807 			//Test Lock

   808 			err = fileplugin.Lock(0,2);

   809 			iLastError = err;

   810 			iLineNumber = __LINE__;

   811 			if(err!=KErrNone)

   812 				User::Leave(err); //trapped in DoRequestL

   814 			err = fileplugin.UnLock(0,2);

   815 			iLastError = err;

   816 			iLineNumber = __LINE__;

   817 			if(err!=KErrNone)

   818 				User::Leave(err); //trapped in DoRequestL

   819 			//End test lock

   821 			err = fileplugin.Write(pos, tempBufPtr);

   822 			_LOG2(_L("CModifierPlugin::FsFileWriteL, RFilePlugin::Write returned %d"), err);

   823 			iLastError = err;

   824 			iLineNumber = __LINE__;

   825 			if(err!=KErrNone)

   826 				User::Leave(err); //trapped in DoRequestL

   828 			//Test sending multiple plugin requests using the RFilePlugin class

   829 			HBufC8* tempBuf2 = HBufC8::NewMaxLC(length);

   830 			TPtr8 tempBufPtr2((TUint8 *)tempBuf2->Des().Ptr(), length, length);

   831 			err = fileplugin.Read(pos, tempBufPtr2);

   832 			_LOG2(_L("CModifierPlugin::FsFileWriteL, RFilePlugin::Read returned %d"), err);

   833 			iLastError = err;

   834 			iLineNumber = __LINE__;

   835 			if(err!=KErrNone)

   836 				User::Leave(err); //trapped in DoRequestL

   838 			//testing the correct thing has been written to the drive

   839 			err = tempBufPtr.Compare(tempBufPtr2);

   840 			iLastError = err;

   841 			iLineNumber = __LINE__;

   842 			if(err!=KErrNone)

   843 				User::Leave(err); //trapped in DoRequestL

   845 			RFilePlugin fileplugin2(aRequest);

   847 			//open a second file

   849 			err = fileplugin2.Open(testfilename1, EFileWrite);

   850 			_LOG3(_L("CModifierPlugin::FsFileWriteL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

   851 			iLastError = err;

   852 			iLineNumber = __LINE__;

   853 			if(err!=KErrNone)

   854 				User::Leave(err); //trapped in DoRequestL

   857 			//write to the second file

   858 			err = fileplugin2.Write(pos, tempBufPtr2);

   859 			_LOG2(_L("CModifierPlugin::FsFileWriteL, RFilePlugin::Write to the second file returned %d"), err);

   860 			iLastError = err;

   861 			iLineNumber = __LINE__;

   862 			if(err!=KErrNone)

   863 				User::Leave(err); //trapped in DoRequestL

   865 			//close the second file

   866 			fileplugin2.Close();

   867 			_LOG2(_L("CModifierPlugin::FsFileWriteL, RFilePlugin::Close to the second file returned %d"), err);

   869 			//read from the first file

   870 			HBufC8* tempBuf3 = HBufC8::NewMaxLC(length);

   871 			TPtr8 tempBufPtr3((TUint8 *)tempBuf3->Des().Ptr(), length, length);

   872 			err = fileplugin.Read(pos, tempBufPtr3);

   873 			_LOG2(_L("CModifierPlugin::FsFileWriteL, RFilePlugin::Read returned %d"), err);

   874 			iLastError = err;

   875 			iLineNumber = __LINE__;

   876 			if(err!=KErrNone)

   877 				User::Leave(err); //trapped in DoRequestL

   879 			RFsPlugin fsplugin(aRequest);

   880 			err = fsplugin.Connect();

   881 			iLastError = err;

   882 			iLineNumber = __LINE__;

   883 			if(err!=KErrNone)

   884 				User::Leave(err); //trapped in DoRequestL

   886 			err = fsplugin.Delete(testfilename2);

   887 			if(err == KErrNone || err == KErrNotFound)

   888 				err = KErrNone;

   890 			iLastError = err;

   891 			iLineNumber = __LINE__;

   892 			if(err!=KErrNone)

   893 				User::Leave(err); //trapped in DoRequestL

   895 			//close the first file.

   896 			fileplugin.Close();

   898 			//Create new file

   899 			err = fileplugin.Create(testfilename2, EFileWrite);

   900 			iLastError = err;

   901 			iLineNumber = __LINE__;

   902 			if(err!=KErrNone)

   903 				User::Leave(err); //trapped in DoRequestL

   904 			_LOG2(_L("CModifierPlugin::FsFileWriteL, RFilePlugin::Create returned %d"), err);

   906 			//write to the newly created file

   907 			err = fileplugin.Write(pos, tempBufPtr2);

   908 			_LOG2(_L("CModifierPlugin::FsFileWriteL, RFilePlugin::Write to the newly created file returned %d"), err);

   909 			iLastError = err;

   910 			iLineNumber = __LINE__;

   911 			if(err!=KErrNone)

   912 				User::Leave(err); //trapped in DoRequestL

   914 			//close the newly created file

   915 			fileplugin.Close();

   917 			//delete the newly created file

   918 			err = fsplugin.Delete(testfilename2);

   919 			iLastError = err;

   920 			iLineNumber = __LINE__;

   921 			if(err!=KErrNone)

   922 				User::Leave(err); //trapped in DoRequestL

   924 			fsplugin.Close();

   926 			CleanupStack::PopAndDestroy();

   928 			// request processed by plug-in

   929 			User::Leave(KErrCompletion);

   930 			}

   931 		}

   932 	}

   936 /**

   937 @internalComponent

   938 */

   939 void CModifierPlugin::FsFileRenameL(TFsPluginRequest& aRequest)

   940 	{

   941 	TFileName oldfilename, newfilename;

   942 	TParse parse;

   944 	oldfilename = aRequest.Src().FullName();

   945 	newfilename = aRequest.Dest().FullName();

   947     parse.Set(oldfilename, NULL, NULL);

   948 	TPtrC extension(parse.Ext());

   950 	_LOG3(_L("CModifierPlugin::FsFileRenameL, old name: %S, new name: %S"), &oldfilename, &newfilename);

   952 	if (aRequest.IsPostOperation())

   953 		{

   954 		_LOG(_L("CModifierPlugin::FsFileRenameL, post intercept"));

   956 		if (extension.CompareF(_L(".tst")) == 0)

   957 			{

   958 			TBuf8<32> tempBuf = (_L8("Rename Post Intercept"));

   959 			RFilePlugin fileplugin(aRequest);

   960 			TInt err = fileplugin.AdoptFromClient();

   961 			iLastError = err;

   962 			iLineNumber = __LINE__;

   963 			if(err!=KErrNone)

   964 				User::Leave(err); //trapped in DoRequestL

   966 			err = fileplugin.Write(20, tempBuf);

   967 			_LOG2(_L("CModifierPlugin::FsFileRenameL, FileWrite returned %d"), err);

   968 			fileplugin.Close();

   969 			iLastError = err;

   970 			iLineNumber = __LINE__;

   971 			if(err!=KErrNone)

   972 				User::Leave(err); //trapped in DoRequestL

   974 			}

   975 		}

   976 	else

   977 		{

   978 		_LOG(_L("CModifierPlugin::FsFileRenameL, pre intercept"));

   980 		if (extension.CompareF(_L(".tst")) == 0)

   981 			{

   982 			TBuf8<32> tempBuf = (_L8("Rename Pre Intercept"));

   983 			RFilePlugin fileplugin(aRequest);

   984 			TInt err = fileplugin.AdoptFromClient();

   985 			iLastError = err;

   986 			iLineNumber = __LINE__;

   987 			if(err!=KErrNone)

   988 				User::Leave(err); //trapped in DoRequestL

   990 			err = fileplugin.Write(0, tempBuf);

   991 			_LOG2(_L("CModifierPlugin::FsFileRenameL, FileWrite returned %d"), err);

   992 			iLastError = err;

   993 			iLineNumber = __LINE__;

   994 			if(err!=KErrNone)

   995 				User::Leave(err); //trapped in DoRequestL

   997 			err = fileplugin.Rename(newfilename);

   998 			_LOG2(_L("CModifierPlugin::FsFileRenameL, FilePlugin::Rename returned %d"), err);

   999 			iLastError = err;

  1000 			iLineNumber = __LINE__;

  1001 			if(err!=KErrNone)

  1002 				User::Leave(err); //trapped in DoRequestL

  1004 			fileplugin.Close();

  1005 			User::Leave(KErrCompletion);

  1006 			}

  1007 		}

  1008 	}

  1011 void CModifierPlugin::FsFileCreateL(TFsPluginRequest& aRequest)

  1012 	{

  1013 	TFileName filename;

  1014 	TParse parse;

  1016 	filename = aRequest.Src().FullName();

  1018 	TUint mode;

  1019 	TInt err = aRequest.Read(TFsPluginRequest::EMode, mode);

  1020 	iLastError = err;

  1021 	iLineNumber = __LINE__;

  1022 	if(err!=KErrNone)

  1023 		User::Leave(err); //trapped in DoRequestL

  1025     parse.Set(filename, NULL, NULL);

  1026 	TPtrC extension(parse.Ext());

  1028 	if (aRequest.IsPostOperation())

  1029 		{

  1030 		_LOG(_L("CModifierPlugin::FsFileCreateL, post intercept"));

  1032 		if (extension.CompareF(_L(".tst")) == 0)

  1033 			{

  1034 			RFilePlugin fileplugin(aRequest);

  1035 			TInt err = fileplugin.AdoptFromClient();

  1036 			iLastError = err;

  1037 			iLineNumber = __LINE__;

  1038 			if(err!=KErrNone)

  1039 				User::Leave(err); //trapped in DoRequestL

  1041 			//write to the newly created file

  1042 			TBuf8<64> wbuffer;

  1043 			wbuffer.Copy(_L8("TestTestTest"));

  1044 	    	err = fileplugin.Write(0, wbuffer);

  1045 			_LOG2(_L("CModifierPlugin::FsFileCreateL, RFilePlugin::Write to the newly created file returned %d"), err);

  1046 			iLastError = err;

  1047 			iLineNumber = __LINE__;

  1048 			if(err!=KErrNone)

  1049 				User::Leave(err); //trapped in DoRequestL

  1051 			TInt length = wbuffer.Length();

  1052 			HBufC8* tempBuf = HBufC8::NewMaxLC(length);

  1053 			TPtr8 tempBufPtr((TUint8 *)tempBuf->Des().Ptr(), length, length);

  1054 			err = fileplugin.Read(0, tempBufPtr);

  1055 			_LOG2(_L("CModifierPlugin::FsFileCreateL, RFilePlugin::Read returned %d"), err);

  1056 			iLastError = err;

  1057 			iLineNumber = __LINE__;

  1058 			if(err!=KErrNone)

  1059 				User::Leave(err); //trapped in DoRequestL

  1061 			//testing the correct thing has been written to the drive

  1062 			err = wbuffer.Compare(tempBufPtr);

  1063 			iLastError = err;

  1064 			iLineNumber = __LINE__;

  1065 			if(err!=KErrNone)

  1066 				User::Leave(err); //trapped in DoRequestL

  1068 			fileplugin.Close();

  1069 			CleanupStack::PopAndDestroy(); //tempBuf

  1070 			}

  1071 		}

  1072 	else

  1073 		{

  1074 		_LOG(_L("CModifierPlugin::FsFileCreateL, pre intercept"));

  1076 		RFilePlugin fileplugin(aRequest);

  1078 		TInt err = fileplugin.Create(filename, mode);

  1080 		_LOG2(_L("CModifierPlugin::FsFileCreateL, RFilePlugin::Create returned %d"), err);

  1081 		iLastError = err;

  1082 		iLineNumber = __LINE__;

  1083 		if(err!=KErrNone)

  1084 			User::Leave(err); //trapped in DoRequestL

  1086 		err = fileplugin.TransferToClient();

  1087 		iLastError = err;

  1088 		iLineNumber = __LINE__;

  1089 		if(err!=KErrNone)

  1090 			User::Leave(err); //trapped in DoRequestL

  1092 		fileplugin.Close();

  1093 		User::Leave(KErrCompletion);

  1094 		}

  1095 	}

  1097 void CModifierPlugin::FsFileOpenL(TFsPluginRequest& aRequest)

  1098 	{

  1100 	TFileName filename;

  1101 	TParse parse;

  1103 	filename = aRequest.Src().FullName();

  1105 	TUint mode;

  1106 	TInt err = aRequest.Read(TFsPluginRequest::EMode, mode);

  1107 	iLastError = err;

  1108 	iLineNumber = __LINE__;

  1109 	if(err!=KErrNone)

  1110 		User::Leave(err); //trapped in DoRequestL

  1112 	parse.Set(filename, NULL, NULL);

  1113 	TPtrC extension(parse.Ext());

  1115 	_LOG2(_L("CModifierPlugin::FsFileOpenL, file: %S"), &filename);

  1117 	// Check that FileName can't be used in pre-operation (as the handle doesn't exist yet!)

  1118 	TFileName shareName;

  1119 	err = aRequest.FileName(shareName);

  1120 	if (aRequest.IsPostOperation())

  1121 		{

  1122 		err = filename.Compare(shareName);

  1123 		iLastError = err;

  1124 		iLineNumber = __LINE__;

  1125 		if(err!=KErrNone)

  1126 			User::Leave(err); //trapped in DoRequestL

  1127 		}

  1128 	else if(err != KErrNotSupported)

  1129 		{

  1130 		iLastError = err;

  1131 		iLineNumber = __LINE__;

  1132 		if(err!=KErrNone)

  1133 			User::Leave(err); //trapped in DoRequestL

  1134 		}

  1136 	if (aRequest.IsPostOperation())

  1137 		{

  1138 		_LOG(_L("CModifierPlugin::FsFileOpenL, post intercept"));

  1139 		if ((extension.CompareF(_L(".tst")) == 0) && (aRequest.Message().Int1() != 0) && (mode & EFileWrite))

  1140 			{

  1142 			RFilePlugin fileplugin(aRequest);

  1143 			err = fileplugin.AdoptFromClient();

  1144 			iLastError = err;

  1145 			iLineNumber = __LINE__;

  1146 			if(err!=KErrNone)

  1147 				User::Leave(err); //trapped in DoRequestL

  1149 			//write to the newly opened file

  1150 			TBuf8<64> wbuffer;

  1151 			wbuffer.Copy(_L8("TestTestTest"));

  1152 			err = fileplugin.Write(0, wbuffer);

  1153 			_LOG2(_L("CModifierPlugin::FsFileOpenL, RFilePlugin::Write to the newly opened file returned %d"), err);

  1154 			iLastError = err;

  1155 			iLineNumber = __LINE__;

  1156 			if(err!=KErrNone)

  1157 				User::Leave(err); //trapped in DoRequestL

  1159 			TInt length = wbuffer.Length();

  1160 			HBufC8* tempBuf = HBufC8::NewMaxLC(length);

  1161 			TPtr8 tempBufPtr((TUint8 *)tempBuf->Des().Ptr(), length, length);

  1162 			err = fileplugin.Read(0, tempBufPtr);

  1163 			_LOG2(_L("CModifierPlugin::FsFileOpenL, RFilePlugin::Read returned %d"), err);

  1164 			iLastError = err;

  1165 			iLineNumber = __LINE__;

  1166 			if(err!=KErrNone)

  1167 				User::Leave(err); //trapped in DoRequestL

  1169 			//testing the correct thing has been written to the drive

  1170 			err = wbuffer.Compare(tempBufPtr);

  1171 			iLastError = err;

  1172 			iLineNumber = __LINE__;

  1173 			if(err!=KErrNone)

  1174 				User::Leave(err); //trapped in DoRequestL

  1176 			fileplugin.Close();

  1178 			CleanupStack::PopAndDestroy(); //tempbuf

  1179 			}

  1180 		}

  1181 	else

  1182 		{

  1183 		_LOG(_L("CModifierPlugin::FsFileOpenL, pre intercept"));

  1185 		RFilePlugin fileplugin(aRequest);

  1186 		err = fileplugin.Open(filename, mode);

  1187 		_LOG3(_L("CModifierPlugin::FsFileOpenL, RFilePlugin::Open for %S returned %d"), &filename, err);

  1188 		iLastError = err;

  1189 		iLineNumber = __LINE__;

  1190 		if(err!=KErrNone)

  1191 			User::Leave(err); //trapped in DoRequestL

  1193 		err = fileplugin.TransferToClient();

  1194 		iLastError = err;

  1195 		iLineNumber = __LINE__;

  1196 		if(err!=KErrNone)

  1197 			User::Leave(err); //trapped in DoRequestL

  1199 		User::Leave(KErrCompletion); // STF : Completing and not setting the handle of the original request?

  1200 		}

  1201 	}

  1204 void CModifierPlugin::FsFileTempL(TFsPluginRequest& aRequest)

  1205 	{

  1206 	TBuf<256> testfilename1;

  1208 	//setting up test files

  1209 	testfilename1.Append(iDriveToTest);

  1210 	testfilename1.Append(_L(":\\Data\\"));

  1212 	if (aRequest.IsPostOperation())

  1213 		{

  1214 		_LOG(_L("CModifierPlugin::FsFileTempL, post intercept"));

  1216 		RFilePlugin fileplugin(aRequest);

  1217 		TInt err = fileplugin.AdoptFromClient();

  1218 		iLastError = err;

  1219 		iLineNumber = __LINE__;

  1220 		if(err!=KErrNone)

  1221 			User::Leave(err); //trapped in DoRequestL

  1223 		//write to the newly created temp file

  1224 		TBuf8<64> wbuffer;

  1225 		wbuffer.Copy(_L8("TestTestTest"));

  1226 		err = fileplugin.Write(0, wbuffer);

  1227 		_LOG2(_L("CModifierPlugin::FsFileTempL, RFilePlugin::Write to the newly created temp file returned %d"), err);

  1228 		iLastError = err;

  1229 		iLineNumber = __LINE__;

  1230 		if(err!=KErrNone)

  1231 			User::Leave(err); //trapped in DoRequestL

  1233 		TInt length = wbuffer.Length();

  1234 		HBufC8* tempBuf = HBufC8::NewMaxLC(length);

  1235 		TPtr8 tempBufPtr((TUint8 *)tempBuf->Des().Ptr(), length, length);

  1236 		err = fileplugin.Read(0, tempBufPtr);

  1237 		_LOG2(_L("CModifierPlugin::FsFileTempL, RFilePlugin::Read returned %d"), err);

  1238 		iLastError = err;

  1239 		iLineNumber = __LINE__;

  1240 		if(err!=KErrNone)

  1241 			User::Leave(err); //trapped in DoRequestL

  1243 		fileplugin.Close();

  1245 		//testing the correct thing has been written to the drive

  1246 		err = wbuffer.Compare(tempBufPtr);

  1247 		iLastError = err;

  1248 		iLineNumber = __LINE__;

  1249 		if(err!=KErrNone)

  1250 			User::Leave(err); //trapped in DoRequestL

  1252 		CleanupStack::PopAndDestroy();

  1253 		}

  1254 	else

  1255 		{

  1256 		_LOG(_L("CModifierPlugin::FsFileTempL, pre intercept"));

  1258 		TInt mode;

  1259 		TInt err = aRequest.Read(TFsPluginRequest::EMode, mode);

  1260 		iLastError = err;

  1261 		iLineNumber = __LINE__;

  1262 		if(err!=KErrNone)

  1263 			User::Leave(err); //trapped in DoRequestL

  1265 		TFileName fn;

  1266 		RFilePlugin fileplugin(aRequest);

  1267 		err = fileplugin.Temp(testfilename1, fn, mode);

  1268 		_LOG2(_L("CModifierPlugin::FsFileTempL, RFilePlugin::Temp returned %d"), err);

  1269 		iLastError = err;

  1270 		iLineNumber = __LINE__;

  1271 		if(err!=KErrNone)

  1272 			User::Leave(err); //trapped in DoRequestL

  1274 		err = aRequest.Write(TFsPluginRequest::ENewName, fn);

  1275 		_LOG2(_L("CModifierPlugin::FsFileTempL, ClientWrite returned %d"), err);

  1276 		iLastError = err;

  1277 		iLineNumber = __LINE__;

  1278 		if(err!=KErrNone)

  1279 			User::Leave(err); //trapped in DoRequestL

  1281 		err = fileplugin.TransferToClient();

  1282 		iLastError = err;

  1283 		iLineNumber = __LINE__;

  1284 		if(err!=KErrNone)

  1285 			User::Leave(err); //trapped in DoRequestL

  1287 		fileplugin.Close();

  1289 		User::Leave(KErrCompletion);

  1290 		}

  1291 	}

  1294 void CModifierPlugin::FsFileReplaceL(TFsPluginRequest& aRequest)

  1295 	{

  1296 	TFileName filename;

  1297 	TParse parse;

  1299 	filename = aRequest.Src().FullName();

  1301 	TUint mode;

  1302 	TInt err = aRequest.Read(TFsPluginRequest::EMode, mode);

  1303 	iLastError = err;

  1304 	iLineNumber = __LINE__;

  1305 	if(err!=KErrNone)

  1306 		User::Leave(err); //trapped in DoRequestL

  1308 	parse.Set(filename, NULL, NULL);

  1309 	TPtrC extension(parse.Ext());

  1311 	_LOG2(_L("CModifierPlugin::FsFileReplaceL, file: %S"), &filename);

  1313 	if (aRequest.IsPostOperation())

  1314 		{

  1315 		_LOG(_L("CModifierPlugin::FsFileReplaceL, post intercept"));

  1316 		if ((extension.CompareF(_L(".tst")) == 0) && (aRequest.Message().Int1() != 0))

  1317 			{

  1318 			//write to the newly replaced file

  1319 			TBuf8<64> wbuffer;

  1320 			wbuffer.Copy(_L8("TestTestTest"));

  1322 			RFilePlugin fileplugin(aRequest);

  1323 			TInt err = fileplugin.AdoptFromClient();

  1324 			iLastError = err;

  1325 			iLineNumber = __LINE__;

  1326 			if(err!=KErrNone)

  1327 				User::Leave(err); //trapped in DoRequestL

  1329     		err = fileplugin.Write(0, wbuffer);

  1330 			_LOG2(_L("CModifierPlugin::FsFileReplaceL, RFilePlugin::Write to the newly created file returned %d"), err);

  1331 			iLastError = err;

  1332 			iLineNumber = __LINE__;

  1333 			if(err!=KErrNone)

  1334 				User::Leave(err); //trapped in DoRequestL

  1336 			TInt length = wbuffer.Length();

  1337 			HBufC8* tempBuf = HBufC8::NewMaxLC(length);

  1338 			TPtr8 tempBufPtr((TUint8 *)tempBuf->Des().Ptr(), length, length);

  1339 			err = fileplugin.Read(0, tempBufPtr);

  1340 			_LOG2(_L("CModifierPlugin::FsFileReplaceL, RFilePlugin::Read returned %d"), err);

  1341 			iLastError = err;

  1342 			iLineNumber = __LINE__;

  1343 			if(err!=KErrNone)

  1344 				User::Leave(err); //trapped in DoRequestL

  1346 			//testing the correct thing has been written to the drive

  1347 			err = wbuffer.Compare(tempBufPtr);

  1348 			iLastError = err;

  1349 			iLineNumber = __LINE__;

  1350 			if(err!=KErrNone)

  1351 				User::Leave(err); //trapped in DoRequestL

  1352 			fileplugin.Close();

  1353 			CleanupStack::PopAndDestroy();

  1354 			}

  1355 		}

  1356 	else

  1357 		{

  1358 		RFilePlugin fileplugin(aRequest);

  1360 		TInt err = fileplugin.Replace(filename, mode);

  1361 		_LOG2(_L("CModifierPlugin::FsFileReplaceL, RFilePlugin::Replace returned %d"), err);

  1362 		iLastError = err;

  1363 		iLineNumber = __LINE__;

  1364 		if(err!=KErrNone)

  1365 			User::Leave(err); //trapped in DoRequestL

  1367 		err = fileplugin.TransferToClient();

  1368 		iLastError = err;

  1369 		iLineNumber = __LINE__;

  1370 		if(err!=KErrNone)

  1371 			User::Leave(err); //trapped in DoRequestL

  1373 		fileplugin.Close();

  1374 		User::Leave(KErrCompletion);

  1375 		}

  1376 	}

  1380 void CModifierPlugin::FsReadFileSectionL(TFsPluginRequest& aRequest)

  1381 	{

  1382 	TInt err = KErrNone;

  1383 	TInt length = 0;

  1384 	TInt64 pos = 0;

  1385 	TFileName filename;

  1386 	TParse parse;

  1387 	TBuf<256> testfilename1;

  1389 	//setting up test files

  1390 	testfilename1.Append(iDriveToTest);

  1391 	testfilename1.Append(_L(":\\Data\\test.txt"));

  1393 	filename = aRequest.Src().FullName();

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

  1396 	iLastError = err;

  1397 	iLineNumber = __LINE__;

  1398 	if(err!=KErrNone)

  1399 		User::Leave(err); //trapped in DoRequestL

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

  1402 	iLastError = err;

  1403 	iLineNumber = __LINE__;

  1404 	if(err!=KErrNone)

  1405 		User::Leave(err); //trapped in DoRequestL

  1407     parse.Set(filename, NULL, NULL);

  1408 	TPtrC extension(parse.Ext());

  1410 	_LOG2(_L("CModifierPlugin::FsReadFileSectionL, file: %S"), &filename);

  1412 	if (aRequest.IsPostOperation())

  1413 		{

  1414 		_LOG(_L("CModifierPlugin::FsReadFileSectionL, post intercept"));

  1415 		User::Invariant();

  1416 		_LOG(_L("CModifierPlugin::FsReadFileSectionL - Exit"));

  1417 		}

  1418 	else

  1419 		{

  1420 		_LOG(_L("CModifierPlugin::FsReadFileSectionL, pre intercept - enter"));

  1422 		if (extension.CompareF(_L(".tst")) == 0)

  1423 			{

  1425 			RFilePlugin fileplugin2(aRequest);

  1426 			//open a second file

  1427 			err = fileplugin2.Open(testfilename1, EFileWrite);

  1428 			_LOG3(_L("CModifierPlugin::FsReadFileSectionL - RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1429 			iLastError = err;

  1430 			iLineNumber = __LINE__;

  1431 			if(err!=KErrNone)

  1432 				User::Leave(err); //trapped in DoRequestL

  1434 			TInt64 size=0;

  1435 			err = fileplugin2.Size(size);

  1436 			iLastError = err;

  1437 			iLineNumber = __LINE__;

  1438 			if(err!=KErrNone)

  1439 				User::Leave(err); //trapped in DoRequestL

  1441 			//close the second file

  1442 			fileplugin2.Close();

  1443 			_LOG(_L("CModifierPlugin::FsReadFileSectionL - fileplugin2.Close()"));

  1445 			TBuf8<26> temp;

  1447 			RFsPlugin fsplugin(aRequest);

  1448 			err = fsplugin.Connect();

  1449 			iLastError = err;

  1450 			iLineNumber = __LINE__;

  1451 			if(err!=KErrNone)

  1452 				User::Leave(err); //trapped in DoRequestL

  1454 			err = fsplugin.ReadFileSection(filename, pos, temp, length);

  1455 			_LOG3(_L("CModifierPlugin::FsReadFileSectionL - RFsPlugin::ReadFilePlugin for %S returned %d"), &testfilename1, err);

  1456 			iLastError = err;

  1457 			iLineNumber = __LINE__;

  1458 			if(err!=KErrNone)

  1459 				User::Leave(err); //trapped in DoRequestL

  1460 			fsplugin.Close();

  1462 			TBuf<26> temp_wide;

  1463 			temp_wide.Copy(temp);

  1465 			iLogging = ETrue;

  1466 			_LOG2(_L("CModifierPlugin::FsReadFileSectionL - wanted to read length = %d\n"),length);

  1467 			_LOG2(_L("CModifierPlugin::FsReadFileSectionL - data read length = %d\n"),temp.Length());

  1468 			_LOG2(_L("CModifierPlugin::FsReadFileSectionL - data read = %S\n"),&temp_wide);

  1469 			iLogging = EFalse;

  1472 			err = aRequest.Write(TFsPluginRequest::EData, temp);

  1473 			_LOG3(_L("CModifierPlugin::FsReadFileSectionL - RFilePlugin::Write for %S returned %d"), &testfilename1, err);

  1474 			iLastError = err;

  1475 			iLineNumber = __LINE__;

  1476 			if(err!=KErrNone)

  1477 				User::Leave(err); //trapped in DoRequestL

  1479 			// request processed by plug-in

  1480 			User::Leave(KErrCompletion);

  1481 			}

  1482 		_LOG(_L("CModifierPlugin::FsReadFileSectionL, pre intercept - exit"));

  1483 		}

  1484 	}

  1487 void CModifierPlugin::FsDeleteL(TFsPluginRequest& aRequest)

  1488 	{

  1489 	TInt err = KErrNone;

  1490 	TFileName filename;

  1492 	TBuf<256> testfilename1;

  1494 	//setting up test files

  1495 	testfilename1.Append(iDriveToTest);

  1496 	testfilename1.Append(_L(":\\Data\\test.txt"));

  1498 	filename = aRequest.Src().FullName();

  1500 	if (aRequest.IsPostOperation())

  1501 		{

  1502 		_LOG(_L("CModifierPlugin::FsDeleteL, post intercept"));

  1504 		RFilePlugin fileplugin2(aRequest);

  1505 		//open a second file

  1506 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1507 		_LOG3(_L("CModifierPlugin::FsDeleteL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1508 		iLastError = err;

  1509 		iLineNumber = __LINE__;

  1510 		if(err!=KErrNone)

  1511 			User::Leave(err); //trapped in DoRequestL

  1513 		TInt64 size=0;

  1514 		err = fileplugin2.Size(size);

  1515 		iLastError = err;

  1516 		iLineNumber = __LINE__;

  1517 		if(err!=KErrNone)

  1518 			User::Leave(err); //trapped in DoRequestL

  1520 		//close the second file

  1521 		fileplugin2.Close();

  1522 		_LOG2(_L("CModifierPlugin::FsDeleteL, RFilePlugin::Close to the second file returned %d"), err);

  1523 		}

  1524 	else

  1525 		{

  1526 		_LOG(_L("CModifierPlugin::FsDeleteL, pre intercept"));

  1528 		_LOG(_L("CModifierPlugin::FsDeleteL, calling RFsPlugin::Delete"));

  1529 		RFilePlugin fileplugin2(aRequest);

  1530 		//open a second file

  1531 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1532 		_LOG3(_L("CModifierPlugin::FsDeleteL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1533 		iLastError = err;

  1534 		iLineNumber = __LINE__;

  1535 		if(err!=KErrNone)

  1536 			User::Leave(err); //trapped in DoRequestL

  1538 		TInt64 size=0;

  1539 		err = fileplugin2.Size(size);

  1540 		iLastError = err;

  1541 		iLineNumber = __LINE__;

  1542 		if(err!=KErrNone)

  1543 			User::Leave(err); //trapped in DoRequestL

  1545 		//close the second file

  1546 		fileplugin2.Close();

  1547 		_LOG2(_L("CModifierPlugin::FsDeleteL, RFilePlugin::Close to the second file returned %d"), err);

  1549 		RFsPlugin fsplugin(aRequest);

  1550 		err = fsplugin.Connect();

  1551 		iLastError = err;

  1552 		iLineNumber = __LINE__;

  1553 		if(err!=KErrNone)

  1554 			User::Leave(err); //trapped in DoRequestL

  1556 		err = fsplugin.Delete(filename);

  1557 		_LOG2(_L("CModifierPlugin::FsDeleteL, RFsPlugin::Delete returned %d"), err);

  1559 		iLastError = err;

  1560 		iLineNumber = __LINE__;

  1561 		if(err!=KErrNone)

  1562 			User::Leave(err); //trapped in DoRequestL

  1564 		fsplugin.Close();

  1566 		// request processed by plug-in

  1567 		User::Leave(KErrCompletion);

  1568 		}

  1569 	}

  1572 void CModifierPlugin::FsReplaceL(TFsPluginRequest& aRequest)

  1573 	{

  1574 	TInt err = KErrNone;

  1575 	TFileName oldfilename;

  1576 	TFileName newfilename;

  1578 	oldfilename = aRequest.Src().FullName();

  1579 	newfilename = aRequest.Dest().FullName();

  1581 	TBuf<256> testfilename1;

  1583 	//setting up test files

  1584 	testfilename1.Append(iDriveToTest);

  1585 	testfilename1.Append(_L(":\\Data\\test.txt"));

  1588 	if (aRequest.IsPostOperation())

  1589 		{

  1590 		//STF: Is this code going to get called - the pre-operation completes early?

  1592 		_LOG(_L("CModifierPlugin::FsReplaceL, post intercept"));

  1593 		//We should check that the name has changed here.

  1594 		RFilePlugin file(aRequest);

  1595 		TInt err = file.AdoptFromClient();

  1596 		iLastError = err;

  1597 		iLineNumber = __LINE__;

  1598 		if(err!=KErrNone)

  1599 			User::Leave(err); //trapped in DoRequestL

  1601 		TInt compare = oldfilename.Compare(newfilename);

  1602 		if(compare != 0) //is equal

  1603 			{

  1604 			//User::Leave(compare);

  1605 			//It wont be equal as the name is coming from the request aint it.

  1606 			//Bit of a pointless comparison in retrospect eh?

  1607 			}

  1609 		file.Close();

  1611 		RFilePlugin fileplugin2(aRequest);

  1612 		//open a second file

  1613 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1614 		_LOG3(_L("CModifierPlugin::FsReplaceL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1615 		iLastError = err;

  1616 		iLineNumber = __LINE__;

  1617 		if(err!=KErrNone)

  1618 			User::Leave(err); //trapped in DoRequestL

  1620 		TInt64 size=0;

  1621 		err =fileplugin2.Size(size);

  1622 		iLastError = err;

  1623 		iLineNumber = __LINE__;

  1624 		if(err!=KErrNone)

  1625 			User::Leave(err); //trapped in DoRequestL

  1627 		//close the second file

  1628 		fileplugin2.Close();

  1629 		_LOG2(_L("CModifierPlugin::FsReplaceL, RFilePlugin::Close to the second file returned %d"), err);

  1630 		}

  1631 	else

  1632 		{

  1633 		_LOG(_L("CModifierPlugin::FsReplaceL, pre intercept"));

  1634 		RFilePlugin fileplugin2(aRequest);

  1635 		//open a second file

  1636 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1637 		_LOG3(_L("CModifierPlugin::FsReplaceL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1638 		iLastError = err;

  1639 		iLineNumber = __LINE__;

  1640 		if(err!=KErrNone)

  1641 			User::Leave(err); //trapped in DoRequestL

  1643 		TInt64 size=0;

  1644 		err =fileplugin2.Size(size);

  1645 		iLastError = err;

  1646 		iLineNumber = __LINE__;

  1647 		if(err!=KErrNone)

  1648 			User::Leave(err); //trapped in DoRequestL

  1650 		//close the second file

  1651 		fileplugin2.Close();

  1652 		_LOG2(_L("CModifierPlugin::FsReplaceL, FilePlugin::Close to the second file returned %d"), err);

  1654 		_LOG(_L("CModifierPlugin::FsReplaceL, calling RFsPlugin::Replace"));

  1655 		RFsPlugin fsplugin(aRequest);

  1656 		err = fsplugin.Connect();

  1657 		iLastError = err;

  1658 		iLineNumber = __LINE__;

  1659 		if(err!=KErrNone)

  1660 			User::Leave(err); //trapped in DoRequestL

  1662 		err = fsplugin.Replace(oldfilename, newfilename);

  1663 		_LOG2(_L("CModifierPlugin::FsReplaceL, RFsPlugin::Replace returned %d"), err);

  1664 		iLastError = err;

  1665 		iLineNumber = __LINE__;

  1666 		if(err!=KErrNone)

  1667 			User::Leave(err); //trapped in DoRequestL

  1669 		fsplugin.Close();

  1671 		// request processed by plug-in

  1672 		User::Leave(KErrCompletion);

  1673 		}

  1674 	}

  1677 void CModifierPlugin::FsRenameL(TFsPluginRequest& aRequest)

  1678 	{

  1679 	TInt err = KErrNone;

  1680 	TFileName oldfilename;

  1681 	TFileName newfilename;

  1683 	oldfilename = aRequest.Src().FullName();

  1684 	newfilename = aRequest.Dest().FullName();

  1686 	TBuf<256> testfilename1;

  1688 	//setting up test files

  1689 	testfilename1.Append(iDriveToTest);

  1690 	testfilename1.Append(_L(":\\Data\\test.txt"));

  1692 	if (aRequest.IsPostOperation())

  1693 		{

  1694 		_LOG(_L("CModifierPlugin::FsRenameL, post intercept"));

  1695 		RFilePlugin fileplugin2(aRequest);

  1696 		//open a second file

  1697 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1698 		_LOG3(_L("RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1699 		iLastError = err;

  1700 		iLineNumber = __LINE__;

  1701 		if(err!=KErrNone)

  1702 			User::Leave(err); //trapped in DoRequestL

  1704 		TInt64 size=0;

  1705 		err = fileplugin2.Size(size);

  1706 		iLastError = err;

  1707 		iLineNumber = __LINE__;

  1708 		if(err!=KErrNone)

  1709 			User::Leave(err); //trapped in DoRequestL

  1711 		//close the second file

  1712 		fileplugin2.Close();

  1713 		_LOG2(_L("CModifierPlugin::FsRenameL, RFilePlugin::Close to the second file returned %d"), err);

  1714 		}

  1715 	else

  1716 		{

  1717 		_LOG(_L("CModifierPlugin::FsRenameL, pre intercept"));

  1718 		RFilePlugin fileplugin2(aRequest);

  1719 		//open a second file

  1720 		fileplugin2.Open(testfilename1, EFileWrite);

  1721 		_LOG3(_L("CModifierPlugin::FsRenameL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1722 		iLastError = err;

  1723 		iLineNumber = __LINE__;

  1724 		if(err!=KErrNone)

  1725 			User::Leave(err); //trapped in DoRequestL

  1727 		TInt64 size=0;

  1728 		err = fileplugin2.Size(size);

  1729 		iLastError = err;

  1730 		iLineNumber = __LINE__;

  1731 		if(err!=KErrNone)

  1732 			User::Leave(err); //trapped in DoRequestL

  1734 		//close the second file

  1735 		fileplugin2.Close();

  1736 		_LOG2(_L("CModifierPlugin::FsRenameL, RFilePlugin::Close to the second file returned %d"), err);

  1738 		_LOG(_L("CModifierPlugin::FsRenameL, calling RFsPlugin::Rename"));

  1739 		RFsPlugin fsplugin(aRequest);

  1740 		err = fsplugin.Connect();

  1741 		iLastError = err;

  1742 		iLineNumber = __LINE__;

  1743 		if(err!=KErrNone)

  1744 			User::Leave(err); //trapped in DoRequestL

  1746 		err = fsplugin.Rename(oldfilename, newfilename);

  1747 		_LOG2(_L("CModifierPlugin::FsRenameL, RFsPlugin::Rename returned %d"), err);

  1748 		iLastError = err;

  1749 		iLineNumber = __LINE__;

  1750 		if(err!=KErrNone)

  1751 			User::Leave(err); //trapped in DoRequestL

  1752 		fsplugin.Close();

  1754 		// request processed by plug-in

  1755 		User::Leave(KErrCompletion);

  1756 		}

  1757 	}

  1759 void CModifierPlugin::FsEntryL(TFsPluginRequest& aRequest)

  1760 	{

  1761 	TInt err = KErrNone;

  1762 	TFileName filename;

  1764 	filename = aRequest.Src().FullName();

  1766 	TBuf<256> testfilename1;

  1768 	//setting up test files

  1769 	testfilename1.Append(iDriveToTest);

  1770 	testfilename1.Append(_L(":\\Data\\test.txt"));

  1774 	if (aRequest.IsPostOperation())

  1775 		{

  1776 		_LOG(_L("CModifierPlugin::FsEntryL, post intercept"));

  1777 		RFilePlugin fileplugin2(aRequest);

  1778 		//open a second file

  1779 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1780 		_LOG3(_L("CModifierPlugin::FsEntryL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1781 		iLastError = err;

  1782 		iLineNumber = __LINE__;

  1783 		if(err!=KErrNone)

  1784 			User::Leave(err); //trapped in DoRequestL

  1786 		TInt64 size=0;

  1787 		err = fileplugin2.Size(size);

  1788 		iLastError = err;

  1789 		iLineNumber = __LINE__;

  1790 		if(err!=KErrNone)

  1791 			User::Leave(err); //trapped in DoRequestL

  1793 		//close the second file

  1794 		fileplugin2.Close();

  1795 		_LOG2(_L("CModifierPlugin::FsEntryL, RFilePlugin::Close to the second file returned %d"), err);

  1796 		}

  1797 	else

  1798 		{

  1799 		_LOG(_L("CModifierPlugin::FsEntryL, pre intercept"));

  1800 		RFilePlugin fileplugin2(aRequest);

  1801 		//open a second file

  1802 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1803 		_LOG3(_L("CModifierPlugin::FsEntryL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1804 		iLastError = err;

  1805 		iLineNumber = __LINE__;

  1806 		if(err!=KErrNone)

  1807 			User::Leave(err); //trapped in DoRequestL

  1809 		TInt64 size=0;

  1810 		err = fileplugin2.Size(size);

  1811 		iLastError = err;

  1812 		iLineNumber = __LINE__;

  1813 		if(err!=KErrNone)

  1814 			User::Leave(err); //trapped in DoRequestL

  1816 		//close the second file

  1817 		fileplugin2.Close();

  1818 		_LOG2(_L("CModifierPlugin::FsEntryL, RFilePlugin::Close to the second file returned %d"), err);

  1820 		_LOG(_L("CModifierPlugin::FsEntryL, calling RFsPlugin::Entry"));

  1821 		RFsPlugin fsplugin(aRequest);

  1822 		err = fsplugin.Connect();

  1823 		iLastError = err;

  1824 		iLineNumber = __LINE__;

  1825 		if(err!=KErrNone)

  1826 			User::Leave(err); //trapped in DoRequestL

  1828 		TEntry entry;

  1829 		err = fsplugin.Entry(filename, entry);

  1830 		_LOG2(_L("CModifierPlugin::FsEntryL, RFsPlugin::Entry returned %d"), err);

  1831 		iLastError = err;

  1832 		iLineNumber = __LINE__;

  1833 		if(err!=KErrNone)

  1834 			User::Leave(err); //trapped in DoRequestL

  1836 		fsplugin.Close();

  1838 		TPckgC<TEntry> data(entry);

  1839 		err = aRequest.Write(TFsPluginRequest::EEntry, data);

  1840 		iLastError = err;

  1841 		iLineNumber = __LINE__;

  1842 		if(err!=KErrNone)

  1843 			User::Leave(err); //trapped in DoRequestL

  1845 		// request processed by plug-in

  1846 		User::Leave(KErrCompletion);

  1847 		}

  1848 	}

  1851 void CModifierPlugin::FsSetEntryL(TFsPluginRequest& aRequest)

  1852 	{

  1853 	TInt err = KErrNone;

  1854 	TFileName filename;

  1856 	TBuf<256> testfilename1;

  1858 	//setting up test files

  1859 	testfilename1.Append(iDriveToTest);

  1860 	testfilename1.Append(_L(":\\Data\\test.txt"));

  1862 	if (aRequest.IsPostOperation())

  1863 		{

  1864 		_LOG(_L("CModifierPlugin::FsSetEntryL, post intercept"));

  1865 		RFilePlugin fileplugin2(aRequest);

  1866 		//open a second file

  1867 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1868 		_LOG3(_L("CModifierPlugin::FsSetEntryL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1869 		iLastError = err;

  1870 		iLineNumber = __LINE__;

  1871 		if(err!=KErrNone)

  1872 			User::Leave(err); //trapped in DoRequestL

  1874 		TInt64 size=0;

  1875 		err = fileplugin2.Size(size);

  1876 		iLastError = err;

  1877 		iLineNumber = __LINE__;

  1878 		if(err!=KErrNone)

  1879 			User::Leave(err); //trapped in DoRequestL

  1881 		//close the second file

  1882 		fileplugin2.Close();

  1883 		_LOG2(_L("CModifierPlugin::FsSetEntryL, RFilePlugin::Close to the second file returned %d"), err);

  1884 		}

  1885 	else

  1886 		{

  1887 		_LOG(_L("CModifierPlugin::FsSetEntryL, pre intercept"));

  1888 		RFilePlugin fileplugin2(aRequest);

  1889 		//open a second file

  1890 		err = fileplugin2.Open(testfilename1, EFileWrite);

  1891 		_LOG3(_L("CModifierPlugin::FsSetEntryL, RFilePlugin::Open for %S returned %d"), &testfilename1, err);

  1892 		iLastError = err;

  1893 		iLineNumber = __LINE__;

  1894 		if(err!=KErrNone)

  1895 			User::Leave(err); //trapped in DoRequestL

  1897 		TInt64 size=0;

  1898 		err = fileplugin2.Size(size);

  1899 		iLastError = err;

  1900 		iLineNumber = __LINE__;

  1901 		if(err!=KErrNone)

  1902 			User::Leave(err); //trapped in DoRequestL

  1904 		//close the second file

  1905 		fileplugin2.Close();

  1906 		_LOG2(_L("CModifierPlugin::FsSetEntryL, FilePlugin::Close to the second file returned %d"), err);

  1908 		TTime time;

  1909 		TPtr8 t((TUint8*)&time,sizeof(TTime));

  1910 		err = aRequest.Read(TFsPluginRequest::ETime, t);

  1911 		iLastError = err;

  1912 		iLineNumber = __LINE__;

  1913 		if(err!=KErrNone)

  1914 			User::Leave(err); //trapped in DoRequestL

  1916 		filename = aRequest.Src().FullName();

  1918 		TInt setMode, clearMode;

  1919 		err = aRequest.Read(TFsPluginRequest::ESetAtt, setMode);

  1920 		iLastError = err;

  1921 		iLineNumber = __LINE__;

  1922 		if(err!=KErrNone)

  1923 			User::Leave(err); //trapped in DoRequestL

  1925 		err = aRequest.Read(TFsPluginRequest::EClearAtt, clearMode);

  1926 		iLastError = err;

  1927 		iLineNumber = __LINE__;

  1928 		if(err!=KErrNone)

  1929 			User::Leave(err); //trapped in DoRequestL

  1931 		RFsPlugin fsplugin(aRequest);

  1932 		err = fsplugin.Connect();

  1933 		iLastError = err;

  1934 		iLineNumber = __LINE__;

  1935 		if(err!=KErrNone)

  1936 			User::Leave(err); //trapped in DoRequestL

  1938 		err = fsplugin.SetEntry(filename, time, setMode, clearMode);

  1939 		_LOG2(_L("CModifierPlugin::FsSetEntryL, RFsPlugin::SetEntry returned %d"), err);

  1940 		iLastError = err;

  1941 		iLineNumber = __LINE__;

  1942 		if(err!=KErrNone)

  1943 			User::Leave(err); //trapped in DoRequestL

  1944 		fsplugin.Close();

  1946 		// request processed by plug-in

  1947 		User::Leave(KErrCompletion);

  1948 		}

  1949 	}

  1951 /**

  1952 @see TestVolume()

  1953 */

  1954 void CModifierPlugin::FsVolumeL(TFsPluginRequest& aRequest)

  1955 	{

  1956 	if (aRequest.IsPostOperation())

  1957 		{

  1958 		_LOG(_L("CModifierPlugin::FsVolumeL, post intercept"));

  1959 		}

  1960 	else

  1961 		{

  1962 		_LOG(_L("CModifierPlugin::FsVolumeL, pre intercept"));

  1963 		RFsPlugin fsplugin(aRequest);

  1964 		CleanupClosePushL(fsplugin);

  1966 		TInt err = fsplugin.Connect();

  1967 		iLastError = err;

  1968 		iLineNumber = __LINE__;

  1969 		if(err!=KErrNone)

  1970 			User::Leave(err); // Trapped in DoRequestL

  1972 		TVolumeInfo volInfo;

  1973 		TInt drive = (TInt)(iDriveToTest - (TChar)'A');

  1974 		err = fsplugin.Volume(volInfo,drive);

  1975 		_LOG3(_L("CModifierPlugin::FsVolumeL, RFsPlugin::Volume(drive %d) returned %d"), drive, err);

  1976 		iLastError = err;

  1977 		iLineNumber = __LINE__;

  1978 		if(err!=KErrNone)

  1979 			User::Leave(err); // Trapped in DoRequestL

  1981 		// Check that the volume label is the same as what was set in t_plugin_v2

  1982 		_LIT(KVolumeLabel,"1Volume");

  1983 		err = volInfo.iName.Compare(KVolumeLabel);

  1984 		_LOG2(_L("CModifierPlugin::FsVolumeL, Compare volume label returned %d"), err);

  1985 		iLastError = err;

  1986 		iLineNumber = __LINE__;

  1987 		if(err!=KErrNone)

  1988 			User::Leave(err); // Trapped in DoRequestL

  1990 		// Modify volume name

  1991 		_LOG2(_L("CModifierPlugin::FsVolumeL, Old volume name = %S"), &volInfo.iName);

  1992 		TBuf<7> newVolumeName = volInfo.iName;

  1993 		newVolumeName[0] = '2';

  1994 		volInfo.iName = newVolumeName;

  1995 		_LOG2(_L("CModifierPlugin::FsVolumeL, New volume name = %S"), &volInfo.iName);

  1997 		// Send back volume info

  1998 		TPckgC<TVolumeInfo> volInfoPckg(volInfo);

  1999 		err = aRequest.Write(TFsPluginRequest::EVolumeInfo, volInfoPckg);

  2000 		iLastError = err;

  2001 		iLineNumber = __LINE__;

  2002 		if(err!=KErrNone)

  2003 			User::Leave(err); // Trapped in DoRequestL

  2005 		CleanupStack::PopAndDestroy();

  2007 		// Request processed by plug-in

  2008 		User::Leave(KErrCompletion);

  2009 		}

  2010 	}

  2013 /**

  2014 @internalComponent

  2015 */

  2016 void CModifierPlugin::FsFileSubCloseL(TFsPluginRequest& aRequest)

  2017 	{

  2018 	if (aRequest.IsPostOperation())

  2019 		{

  2020 		_LOG(_L("CModifierPlugin::FsFileSubCloseL, post intercept"));

  2021 		}

  2022 	else

  2023 		{

  2024 		_LOG(_L("CModifierPlugin::FsFileSubCloseL, pre intercept"));

  2025 		}

  2026 	}

  2028 /**

  2029 @internalComponent

  2030 */

  2031 void CModifierPlugin::FsDirOpenL(TFsPluginRequest& aRequest)

  2032 	{

  2034 	TBuf<256> testfilename1;

  2036 	TBuf<25> testtemp;

  2037 	TInt err = aRequest.FileName(testtemp);

  2038 	iLastError = err;

  2039 	iLineNumber = __LINE__;

  2040 	if(err!=KErrNone)

  2041 		User::Leave(err); //trapped in DoRequestL

  2043 	//setting up test files

  2044 	testfilename1.Append(iDriveToTest);

  2045 	testfilename1.Append(_L(":\\Data2\\"));

  2047 	if (aRequest.IsPostOperation())

  2048 		{

  2049 		_LOG(_L("CModifierPlugin::FsDirOpenL, post intercept"));

  2050 		}

  2051 	else

  2052 		{

  2053 		_LOG(_L("CModifierPlugin::FsDirOpenL, pre intercept"));

  2055 		_LOG(_L("CModifierPlugin::FsDirOpenL, calling RDirPlugin::Open"));

  2057 		TPckgBuf<TUidType> uidPckg;

  2058 		err = aRequest.Read(TFsPluginRequest::EUid, uidPckg);

  2059 		iLastError = err;

  2060 		iLineNumber = __LINE__;

  2061 		if(err!=KErrNone)

  2062 			User::Leave(err); //trapped in DoRequestL

  2064 		TUidType uidType = uidPckg();

  2065 		TFileName filename;

  2066 		filename = iDirFullName;

  2068 		RDirPlugin dirplugin(aRequest);

  2069 		err = dirplugin.Open(filename, uidType);

  2070 		_LOG2(_L("CModifierPlugin::FsDirOpenL, RDirPlugin::Open returned %d"), err);

  2071 		iLastError = err;

  2072 		iLineNumber = __LINE__;

  2073 		if(err!=KErrNone)

  2074 			User::Leave(err); //trapped in DoRequestL

  2075 		dirplugin.Close();

  2077 		err = dirplugin.Open(testfilename1, uidType);

  2078 		_LOG2(_L("CModifierPlugin::FsDirOpenL, RDirPlugin::Open returned %d"), err);

  2079 		iLastError = err;

  2080 		iLineNumber = __LINE__;

  2081 		if(err!=KErrNone)

  2082 			User::Leave(err); //trapped in DoRequestL

  2084 		dirplugin.Close();

  2085 		}

  2086 	}

  2088 void CModifierPlugin::FsDirReadOneL(TFsPluginRequest& aRequest)

  2089 	{

  2090 	TFileName filename;

  2091 	TInt err = aRequest.FileName(filename);

  2092 	iLastError = err;

  2093 	iLineNumber = __LINE__;

  2094 	if(err!=KErrNone)

  2095 		User::Leave(err); //trapped in DoRequestL

  2097 	TBuf<256> drivename;

  2099 	//setting up test files

  2100 	drivename.Append(iDriveToTest);

  2101 	drivename.Append(_L(":\\"));

  2103 	//filename = iDirFullName; //STF: Can this be policed by checking EParseSrc flag?

  2105 	if (aRequest.IsPostOperation())

  2106 		{

  2107 		_LOG(_L("CModifierPlugin::FsDirReadL, post intercept"));

  2108 		}

  2109 	else

  2110 		{

  2111 		_LOG(_L("CModifierPlugin::FsDirReadL, pre intercept"));

  2113 		TInt x = filename.CompareF(drivename);

  2114 		if(x==0)

  2115 			{

  2116 			RDirPlugin dir(aRequest);

  2117 			err = dir.Open(filename, KEntryAttMatchMask);

  2118 			iLastError = err;

  2119 			iLineNumber = __LINE__;

  2120 			if(err!=KErrNone)

  2121 				User::Leave(err); //trapped in DoRequestL

  2123 			TEntry entry;

  2124 			err = dir.Read(entry);

  2125 			iLastError = err;

  2126 			iLineNumber = __LINE__;

  2127 			if(err!=KErrNone)

  2128 				User::Leave(err); //trapped in DoRequestL

  2130 			_LOG2(_L("CModifierPlugin::FsDirReadL, Read returned %S (first entry)"), &entry.iName);

  2132 			TPckgC<TEntry> data(entry);

  2133 			err = aRequest.Write(TFsPluginRequest::EEntry, data);

  2134 			iLastError = err;

  2135 			iLineNumber = __LINE__;

  2136 			if(err!=KErrNone)

  2137 				User::Leave(err); //trapped in DoRequestL

  2139 			dir.Close();

  2140 			User::Leave(KErrCompletion);

  2141 			}

  2142 		}

  2143 	}

  2146 /**

  2147 @internalComponent

  2148 */

  2149 void CModifierPlugin::FsDirReadPackedL(TFsPluginRequest& aRequest)

  2150 	{

  2151 	TFileName filename;

  2152 	TInt err = aRequest.FileName(filename);

  2153 	iLastError = err;

  2154 	iLineNumber = __LINE__;

  2155 	if(err!=KErrNone)

  2156 		User::Leave(err); //trapped in DoRequestL

  2157 	TParse parse;

  2159     parse.Set(filename, NULL, NULL);

  2160 	//TPtrC extension(parse.Ext());

  2161 	TBuf<256> drivename;

  2163 	//setting up test files

  2164 	drivename.Append(iDriveToTest);

  2165 	drivename.Append(_L(":\\"));

  2167 	//filename = iDirFullName;

  2169 	if (aRequest.IsPostOperation())

  2170 		{

  2171 		_LOG(_L("CModifierPlugin::FsDirReadPackedL, post intercept"));

  2172 		}

  2173 	else

  2174 		{

  2175 		_LOG(_L("CModifierPlugin::FsDirReadPackedL, pre intercept"));

  2177 		TInt x = filename.CompareF(drivename);

  2178 		if(x==0)

  2179 			{

  2180 			RDirPlugin dir(aRequest);

  2181 			err = dir.Open(filename, KEntryAttMatchMask);

  2182 			iLastError = err;

  2183 			iLineNumber = __LINE__;

  2184 			if(err!=KErrNone)

  2185 				User::Leave(err); //trapped in DoRequestL

  2187 			TRawEntryArray aArray;

  2188 			err = dir.Read(aArray);

  2189 			iLastError = err;

  2190 			iLineNumber = __LINE__;

  2191 			if(err!=KErrNone && err!=KErrEof)

  2192 				User::Leave(err); //trapped in DoRequestL

  2194 			TEntry entry = aArray[0];

  2195 			_LOG2(_L("CModifierPlugin::FsDirReadPackedL, Read returned %S (first entry)"), &entry.iName);

  2197 			dir.Close();

  2199 			err = aRequest.Write(TFsPluginRequest::EEntryArray,aArray.Buf()); // Careful not to overwrite the KErrEof

  2200 			iLastError = err;

  2201 			iLineNumber = __LINE__;

  2202 			if(err!=KErrNone)

  2203 				User::Leave(err); //trapped in DoRequestL

  2205 			User::Leave(KErrEof);	//This is effectively a completion code for FSDirReadPacked

  2206 			}

  2207 		}

  2208 	}

  2210 CFsPluginConn* CModifierPlugin::NewPluginConnL()

  2211 	{

  2212 	return new(ELeave) CModifierPluginConn();

  2213 	}

  2216 //Synchronous RPlugin::DoControl

  2217 TInt CModifierPlugin::FsPluginDoControlL(CFsPluginConnRequest& aRequest)

  2218 	{

  2219 	TInt err = KErrNone;

  2221 	//We can use this to set the drive

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

  2224 	TPckg<TInt> errCodeDes(iLastError);

  2225 	TPckg<TInt> lineNumberDes(iLineNumber);

  2226 	TPckg<TChar> drive(iDriveToTest);

  2227 	TPckg<TBool> interceptStatusDes(iInterceptsEnabled);

  2228 	typedef TBuf<256> TDirName;

  2229 	TPckg<TDirName> dirnamePckg(iDirFullName);

  2231 	TInt function = aRequest.Function();

  2232 	switch(function)

  2233 		{

  2234 		case KPluginSetDrive:

  2235 			{

  2236 			TRAP(err,aRequest.ReadParam1L(drive));

  2237 			break;

  2238 			}

  2239 		case KPluginGetError:

  2240 			{

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

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

  2243 			break;

  2244 			}

  2245 		case KPluginToggleIntercepts:

  2246 			{

  2247 			iInterceptsEnabled ^= 1; //toggle intercepts;

  2248 			TRAP(err,aRequest.WriteParam1L(interceptStatusDes));

  2249 			break;

  2250 			}

  2251 		case KPluginSetDirFullName:

  2252 			{

  2253 			//This is necessary as at present we have no way of getting the name of

  2254 			//a directory!

  2255 			TRAP(err,aRequest.ReadParam1L(dirnamePckg));

  2256 			break;

  2257 			}

  2258 		default:

  2259 			break;

  2260 		}

  2262 	return err;

  2263 	}

  2265 TInt CModifierPluginConn::DoControl(CFsPluginConnRequest& aRequest)

  2266 	{

  2267 	return ((CModifierPlugin*)Plugin())->FsPluginDoControlL(aRequest);

  2268 	}

  2270 void CModifierPluginConn::DoRequest(CFsPluginConnRequest& aRequest)

  2271 	{

  2272 	TInt r = DoControl(aRequest);

  2273 	aRequest.Complete(r);

  2274 	}

  2276 void CModifierPluginConn::DoCancel(TInt /*aReqMask*/)

  2277 	{

  2278 	}

  2280 //factory functions

  2282 class CModifierPluginFactory : public CFsPluginFactory

  2283 	{

  2284 public:

  2285 	CModifierPluginFactory();

  2286 	virtual TInt Install();

  2287 	virtual CFsPlugin* NewPluginL();

  2288 	virtual CFsPlugin* NewPluginConnL();

  2289 	virtual TInt UniquePosition();

  2290 	};

  2292 /**

  2293 Constructor for the plugin factory

  2294 @internalComponent

  2295 */

  2296 CModifierPluginFactory::CModifierPluginFactory()

  2297 	{

  2298 	}

  2300 /**

  2301 Install function for the plugin factory

  2302 @internalComponent

  2303 */

  2304 TInt CModifierPluginFactory::Install()

  2305 	{

  2306 	SetSupportedDrives(KPluginSupportAllDrives);

  2307 	//iSupportedDrives = 1<<23;

  2308 	return(SetName(&KModifierPluginName));

  2309 	}

  2311 /**

  2312 @internalComponent

  2313 */

  2314 TInt CModifierPluginFactory::UniquePosition()

  2315 	{

  2316 	return(KModifierPos);

  2317 	}

  2319 /**

  2320 Plugin factory function

  2321 @internalComponent

  2322 */

  2323 CFsPlugin* CModifierPluginFactory::NewPluginL()

  2325 	{

  2326 	return CModifierPlugin::NewL();

  2327 	}

  2329 /**

  2330 Plugin factory function

  2331 @internalComponent

  2332 */

  2333 CFsPlugin* CModifierPluginFactory::NewPluginConnL()

  2335 	{

  2336 	return CModifierPlugin::NewL();

  2337 	}

  2339 /**

  2340 Create a new Plugin

  2341 @internalComponent

  2342 */

  2343 extern "C" {

  2345 EXPORT_C CFsPluginFactory* CreateFileSystem()

  2346 	{

  2347 	return(new CModifierPluginFactory());

  2348 	}

  2349 }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--