MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/kernelhwsrv/kerneltest/f32test/plugins/version_2/src/combinational_plugin.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     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 //

    15 

    16 #include "combinational_plugin.h"

    17 #include "plugincommon.h"

    18 #include <f32pluginutils.h>

    19 

    20 /**

    21 Leaving New function for the plugin

    22 @internalComponent

    23 */

    24 CCombinationalPlugin* CCombinationalPlugin::NewL()

    25 	{

    26 	CCombinationalPlugin* self = new(ELeave) CCombinationalPlugin;

    27     CleanupStack::PushL(self);

    28     self->ConstructL();

    29     CleanupStack::Pop();

    30 	return self;

    31 	}

    32 

    33 

    34 /**

    35 Constructor for the plugin

    36 @internalComponent

    37 */

    38 CCombinationalPlugin::CCombinationalPlugin() : iInterceptsEnabled(EFalse),

    39 									 iLogging(ETrue)

    40 	{

    41 	}

    42 

    43 

    44 void CCombinationalPlugin::ConstructL()

    45 	{

    46 	//iFile = RFilePlugin::Open();

    47 	}

    48 

    49 /**

    50 The destructor for the plugin

    51 @internalComponent

    52 */

    53 CCombinationalPlugin::~CCombinationalPlugin()

    54 	{

    55 	}

    56 

    57 /**

    58 Initialise the plugin.

    59 @internalComponent

    60 */

    61 void CCombinationalPlugin::InitialiseL()

    62 	{

    63 	_LOG(_L("CCombinationalPlugin InitialiseL"));

    64 	EnableInterceptsL();

    65 	}

    66 

    67 /**

    68 Enable the plugin's intercepts.

    69 @internalComponent

    70 */

    71 void CCombinationalPlugin::EnableInterceptsL()

    72 	{

    73 	if (iInterceptsEnabled) return;

    74 	

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

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

    77 	User::LeaveIfError(RegisterIntercept(EFsDirOpen,			EPrePostIntercept));

    78 	User::LeaveIfError(RegisterIntercept(EFsFileLock,			EPrePostIntercept));

    79 	User::LeaveIfError(RegisterIntercept(EFsFileUnLock,			EPrePostIntercept));

    80 	User::LeaveIfError(RegisterIntercept(EFsFileSeek,			EPrePostIntercept));

    81 	User::LeaveIfError(RegisterIntercept(EFsFileSize,			EPrePostIntercept));

    82 	User::LeaveIfError(RegisterIntercept(EFsFileSetSize,		EPrePostIntercept));

    83 	User::LeaveIfError(RegisterIntercept(EFsDirReadOne,			EPrePostIntercept));

    84 	User::LeaveIfError(RegisterIntercept(EFsDirReadPacked,		EPrePostIntercept));

    85 	User::LeaveIfError(RegisterIntercept(EFsFileOpen,			EPrePostIntercept));

    86 	User::LeaveIfError(RegisterIntercept(EFsFileCreate,			EPrePostIntercept));

    87 	User::LeaveIfError(RegisterIntercept(EFsFileReplace,		EPrePostIntercept));

    88 	User::LeaveIfError(RegisterIntercept(EFsFileRename,			EPrePostIntercept));

    89    	User::LeaveIfError(RegisterIntercept(EFsReadFileSection,	EPrePostIntercept));

    90 	User::LeaveIfError(RegisterIntercept(EFsFileSubClose,       EPrePostIntercept));

    91 	User::LeaveIfError(RegisterIntercept(EFsEntry,        		EPrePostIntercept));

    92 	User::LeaveIfError(RegisterIntercept(EFsSetEntry,      		EPrePostIntercept));

    93 

    94 	_LOG(_L("Combinational Plugin: Enabled intercepts."));

    95     

    96 	iInterceptsEnabled = ETrue;

    97 	}

    98 

    99 /**

   100 Disable the plugin's intercepts.

   101 @internalComponent

   102 */

   103 void CCombinationalPlugin::DisableInterceptsL()

   104 	{

   105 	if (!iInterceptsEnabled) return;

   106 	

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

   108 	User::LeaveIfError(UnregisterIntercept(EFsFileRename,		EPrePostIntercept));

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

   110 	User::LeaveIfError(UnregisterIntercept(EFsDirOpen,			EPrePostIntercept));

   111 	User::LeaveIfError(UnregisterIntercept(EFsFileLock,			EPrePostIntercept));

   112 	User::LeaveIfError(UnregisterIntercept(EFsFileUnLock,		EPrePostIntercept));

   113 	User::LeaveIfError(UnregisterIntercept(EFsFileSeek,			EPrePostIntercept));

   114 	User::LeaveIfError(UnregisterIntercept(EFsFileSize,			EPrePostIntercept));

   115 	User::LeaveIfError(UnregisterIntercept(EFsFileSetSize,		EPrePostIntercept));

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

   117 	User::LeaveIfError(UnregisterIntercept(EFsFileOpen, 		EPrePostIntercept));

   118 	User::LeaveIfError(UnregisterIntercept(EFsFileReplace, 		EPrePostIntercept));

   119 	User::LeaveIfError(UnregisterIntercept(EFsFileSubClose, 	EPrePostIntercept));

   120 	User::LeaveIfError(UnregisterIntercept(EFsReadFileSection,	EPrePostIntercept));

   121 	User::LeaveIfError(UnregisterIntercept(EFsDirReadOne,		EPrePostIntercept));

   122 	User::LeaveIfError(UnregisterIntercept(EFsDirReadPacked,	EPrePostIntercept));

   123 	User::LeaveIfError(UnregisterIntercept(EFsEntry,        	EPrePostIntercept));

   124 	User::LeaveIfError(UnregisterIntercept(EFsSetEntry,      	EPrePostIntercept));

   125 

   126 	_LOG(_L("Combinational Plugin: Disabled intercepts."));

   127     

   128 	iInterceptsEnabled = EFalse;

   129 	}

   130 

   131 /**

   132 Handle requests

   133 @internalComponent

   134 */

   135 TInt CCombinationalPlugin::DoRequestL(TFsPluginRequest& aRequest)

   136 	{

   137 	TInt r = KErrNone;

   138 	TInt function = aRequest.Function();

   139 	

   140 	if (aRequest.IsPostOperation())

   141 		{

   142 		_LOG2(_L("CCombinationalPlugin post intercept for function %d"), function);

   143 		}

   144 	else

   145 		{

   146 		_LOG2(_L("CCombinationalPlugin pre intercept for function %d"), function);

   147 		}

   148 

   149 	switch (function)

   150 		{

   151 		case EFsFileOpen:

   152 			r= DoFileOpen(aRequest);

   153 			break;

   154 		case EFsFileSubClose:

   155 			r = DoFileSubClose(aRequest);

   156 			break;

   157 		case EFsFileReplace:

   158 			r = DoFileReplace(aRequest);

   159 			break;

   160 		case EFsEntry:

   161 			r = DoEntry(aRequest);

   162 			break;

   163 		case EFsDirReadPacked:

   164 			r = DoDirReadPacked(aRequest);

   165 			break;

   166 		case EFsDirOpen:

   167 			aRequest.Src();

   168 			break;

   169 		default:

   170 			break;

   171 		}

   172 	return r;

   173 	}

   174 

   175 

   176 

   177 

   178 TInt CCombinationalPlugin::DoFileRead(TFsPluginRequest& /*aRequest*/)

   179 	{

   180 	iLastError = KErrNotSupported;

   181 	iLineNumber = __LINE__;

   182 	return KErrNotSupported;

   183 	}

   184 TInt CCombinationalPlugin::DoFileWrite(TFsPluginRequest& /*aRequest*/)

   185 	{

   186 	iLastError = KErrNotSupported;

   187 	iLineNumber = __LINE__;

   188 	return KErrNotSupported;

   189 	}

   190 

   191 /*

   192 Test - 	Perform an Open here,

   193  		then make sure we get the right details in the second plugin.

   194 */

   195 TInt CCombinationalPlugin::DoEntry(TFsPluginRequest& aRequest)

   196 	{

   197 	TInt err = KErrNone;

   198 	TFileName name;

   199 	

   200 	TBuf<256> testfilename1;

   201 

   202 	//setting up test files

   203 	testfilename1.Append(iDriveToTest);

   204 	testfilename1.Append(_L(":\\data\\test.entry.combi"));

   205 

   206 	name = aRequest.Src().FullName();

   207 	

   208 	if(!aRequest.IsPostOperation()) //pre

   209 		{

   210 		err = KErrNone;

   211 		

   212 		TBuf<256> clientfilename;

   213 		clientfilename.Append(iDriveToTest);

   214 		clientfilename.Append(_L(":\\combi.txt"));

   215 		

   216 		if(name.Compare(clientfilename) == 0)

   217 			{

   218 			RFilePlugin file(aRequest);

   219 			err = file.Replace(testfilename1, EFileWrite);//open

   220 			iLastError = err;

   221 			iLineNumber = __LINE__;

   222 			if(err!=KErrNone)

   223 				return err;

   224 			

   225 			file.Close();

   226 			}

   227 		

   228 		}

   229 	else //post

   230 		{

   231 		TEntry entry;

   232 		TPckg<TEntry> entryPckg(entry);

   233 		err = aRequest.Read(TFsPluginRequest::EEntry, entryPckg);

   234 		iLastError = err;

   235 		iLineNumber = __LINE__;

   236 		if(err!=KErrNone)

   237 			return err;

   238 		}

   239 

   240 	return err;

   241 	}

   242 

   243 TInt CCombinationalPlugin::DoDirReadPacked(TFsPluginRequest& aRequest)

   244 	{

   245 	TInt err = KErrNone;

   246 	

   247 	TBuf<16> compareName;

   248 	compareName.Append(iDriveToTest);

   249 	compareName.Append(_L(":\\dir3\\"));

   250 	if(iDirFullName.Compare(compareName) == 0)

   251 		{

   252 		return KErrNone;

   253 		}

   254 	

   255 	if (aRequest.IsPostOperation()) //Post

   256 		{

   257 		// NOP

   258 		}

   259 	else							//Pre 

   260 		{

   261 		RDirPlugin dir1(aRequest);

   262 		err = dir1.Open(iDirFullName, KEntryAttMatchMask); 

   263 		iLastError = err;

   264 		iLineNumber = __LINE__;

   265 		if(err!=KErrNone)

   266 			return err;

   267 

   268 		TBuf<16> dirname2;

   269 		dirname2.Append(iDriveToTest);

   270 		dirname2.Append(_L(":\\dir2\\"));

   271 		

   272 		TEntryArray entryarray1;

   273 		err = dir1.Read(entryarray1); //we can complete

   274 		iLastError = err;

   275 		iLineNumber = __LINE__;

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

   277 			return err;

   278 

   279 		TUidType uid(TUid::Null(),TUid::Null(),TUid::Null());

   280 	

   281 		RDirPlugin dir2(aRequest);

   282 		err = dir2.Open(dirname2,uid);

   283 		iLastError = err;

   284 		iLineNumber = __LINE__;

   285 		if(err!=KErrNone)

   286 			return err;

   287 		

   288 		TEntryArray entryarray2;

   289 		err = dir2.Read(entryarray2);

   290 		iLastError = err;

   291 		iLineNumber = __LINE__;

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

   293 			return err;

   294 		

   295 		if(entryarray1.Count() >= 1 && entryarray2.Count() >= 1)

   296 			{

   297 			TEntry e1 = entryarray1[0];

   298 			

   299 			TBuf<16> dir1file;

   300 			dir1file.Append(_L("dir1.file"));

   301 			if(e1.iName.Compare(dir1file) != 0)

   302 				{

   303 				iLastError = err;

   304 				iLineNumber = __LINE__;

   305 				if(err!=KErrNone)

   306 					return err;

   307 				}

   308 			}

   309 		else 

   310 			{

   311 			iLastError = err;

   312 			iLineNumber = __LINE__;

   313 			if(err!=KErrNone)

   314 				return err;

   315 			}

   316 		

   317 		TBuf<16> dirname3;

   318 		dirname3.Append(iDriveToTest);

   319 		dirname3.Append(_L(":\\dir3\\"));

   320 

   321 		TRawEntryArray entryarray3;

   322 		RDirPlugin dir3(aRequest);

   323 		TUidType uid3(TUid::Null(), TUid::Null(), TUid::Null());

   324 		err = dir3.Open(dirname3,uid3);

   325 		iLastError = err;

   326 		iLineNumber = __LINE__;

   327 		if(err!=KErrNone)

   328 			return err;

   329 		

   330 		err = dir3.Read(entryarray3);

   331 		iLastError = err;

   332 		iLineNumber = __LINE__;

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

   334 			return err;

   335 		

   336 		err = aRequest.Write(TFsPluginRequest::EEntryArray,entryarray3.Buf());

   337 		iLastError = err;

   338 		iLineNumber = __LINE__;

   339 		if(err!=KErrNone)

   340 			return err;

   341 

   342 		dir1.Close();

   343 		dir2.Close();

   344 		dir3.Close();

   345 		

   346 		return KErrCompletion;

   347 		}

   348 		

   349 	return err;

   350 	}

   351 

   352 

   353 /*

   354 

   355 Test 1 - This test opens 3 files and reads their contents (which was written in the test harness)

   356 

   357 Test 2 - 

   358 

   359 */

   360 TInt CCombinationalPlugin::DoFileOpen(TFsPluginRequest& aRequest)

   361 	{

   362 	//intercept open

   363 	TInt err = KErrNone;

   364 

   365 	if (aRequest.IsPostOperation()) //Post

   366 		{

   367 		//Start of test

   368 		RFilePlugin file(aRequest);

   369 		err = file.AdoptFromClient();

   370 		iLastError = err;

   371 		iLineNumber = __LINE__;

   372 		if(err!=KErrNone)

   373 			return err;

   374 		

   375 		TFileName filename;

   376 		filename.FillZ();

   377 

   378 		//TODO: get rid of this?

   379 		#ifdef __WINS__ 

   380 			_LIT(KSecondFile,"X:\\combi1.txt");

   381 		#else

   382 			_LIT(KSecondFile,"D:\\combi1.txt");

   383 		#endif

   384 

   385 		filename.SetLength(KSecondFile().Length());

   386 		filename.Replace(0,KSecondFile().Length(),KSecondFile());

   387 		

   388 		TUint mode;

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

   390 		iLastError = err;

   391 		iLineNumber = __LINE__;

   392 		if(err!=KErrNone)

   393 			return err;

   394 

   395 		//try to open a second file.			

   396 		err = file.Open(filename, mode);

   397 		

   398 		//NEGATIVE TESTING: 

   399 		if(err!=KErrBadHandle)

   400 			{

   401 			iLastError = err;

   402 			iLineNumber = __LINE__;

   403 			if(err!=KErrNone)

   404 				return err;

   405 			}

   406 		

   407 		RFilePlugin file2(aRequest);

   408 		err = file2.Open(filename, mode);

   409 		iLastError = err;

   410 		iLineNumber = __LINE__;

   411 		if(err!=KErrNone)

   412 			return err;

   413 		

   414 		//Lets write something

   415 		TBuf8<64> combi1Buf;

   416 		combi1Buf.SetLength(10);

   417 		err = file2.Read(0,combi1Buf,6);

   418 		iLastError = err;

   419 		iLineNumber = __LINE__;

   420 		if(err!=KErrNone)

   421 			return err;

   422 		

   423 		// second file is open.

   424 		// lets be wild and open a third!

   425 		filename.FillZ();

   426 		

   427 		//TODO: Get rid of this?

   428 		#ifdef __WINS__ 

   429 			_LIT(KThirdFile,"X:\\combi2.txt");

   430 		#else

   431 			_LIT(KThirdFile,"D:\\combi2.txt");

   432 		#endif

   433 

   434 		filename.SetLength(KThirdFile().Length());

   435 		filename.Replace(0,KThirdFile().Length(),KThirdFile());

   436 		

   437 		RFilePlugin file3(aRequest);

   438 		err = file3.Open(filename, mode);

   439 		User::LeaveIfError(err);

   440 		

   441 		TBuf8<64> combi2Buf;

   442 		combi2Buf.SetLength(20);

   443 		err = file3.Read(0, combi2Buf, 18);

   444 		User::LeaveIfError(err);

   445 		

   446 		_LOG2(_L("combi1Buf := %S"),&combi1Buf);

   447 		_LOG2(_L("combi2Buf := %S"),&combi2Buf);

   448 		

   449 		err = combi1Buf.Compare(combi2Buf);

   450 		if(err != 0) // is equal

   451 		    {

   452 			iLastError = err;

   453 			iLineNumber = __LINE__;

   454 			return err;

   455 		    }

   456 		

   457 		// Right, best close these then eh?

   458 		

   459 		//close in different order - should be fine.

   460 		file2.Close();

   461 		file.Close();

   462 		file3.Close();

   463 		

   464 		return KErrNone;

   465 		} 

   466 	else // PRE

   467 		{

   468 		RFilePlugin file(aRequest);

   469 		

   470 		TFileName filename;

   471 

   472 

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

   474 

   475 		TUint mode;

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

   477 		iLastError = err;

   478 		iLineNumber = __LINE__;

   479 		if(err!=KErrNone)

   480 			return err;

   481 

   482 		// Combinational test 1) Try to perform an RfilePlugin:Open on the same file.

   483 		err = file.Open(filename, mode);

   484 		iLastError = err;

   485 		iLineNumber = __LINE__;

   486 		if(err!=KErrNone)

   487 			return err;

   488 

   489 		err = file.TransferToClient();

   490 		iLastError = err;

   491 		iLineNumber = __LINE__;

   492 		if(err!=KErrNone)

   493 			return err;

   494 

   495 		file.Close();

   496 

   497 		return KErrCompletion;

   498 		}

   499 	}

   500 

   501 TInt CCombinationalPlugin::DoFileSubClose(TFsPluginRequest& aRequest)

   502 	{

   503 	TInt err = KErrNone;

   504 	if (aRequest.IsPostOperation())

   505 		{

   506 		} 

   507 	else 

   508 		{ //PRE

   509 		RFilePlugin file(aRequest);

   510 		err = file.AdoptFromClient(); //This is weird but it follows the open/close pattern;

   511 		iLastError = err;

   512 		iLineNumber = __LINE__;

   513 		if(err!=KErrNone)

   514 			return err;

   515 		file.Close(); 

   516 		}

   517 	return err;

   518 	}

   519 

   520 /*

   521  * This test is testing the following scenario : 

   522  * 

   523 Intercept Replace:

   524 	plugin: replace file1, write to file1,replace file2, write to file2, rfsplugin.delete file3, create file3, write3, read, compare, close, read, compare 2, close, read, compare 1, close.

   525 	(basically, open/replace/create 3 files, write to them and read back from them and check the contents)  

   526  */

   527 TInt CCombinationalPlugin::DoFileReplace(TFsPluginRequest& aRequest)

   528 	{

   529 	TInt err = KErrNone;

   530 

   531 	TBuf<256> testfilename1;

   532 	TBuf<256> testfilename2;

   533 

   534 	//setting up test files

   535 	testfilename1.Append(iDriveToTest);

   536 	testfilename1.Append(_L(":\\combiReplace2.txt"));

   537 

   538 	testfilename2.Append(iDriveToTest);

   539 	testfilename2.Append(_L(":\\combiReplace3.txt"));

   540 

   541 	if (aRequest.IsPostOperation()) //POST

   542 		{

   543 		}

   544 	else //PRE

   545 		{

   546 		TFileName filename;

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

   548 		

   549 		RFsPlugin rfs(aRequest);

   550 		err = rfs.Connect();

   551 		iLastError = err;

   552 		iLineNumber = __LINE__;

   553 		if(err!=KErrNone)

   554 			return err;

   555 

   556 		//rfs.Delete(aRequest,filename);

   557 		

   558 		RFilePlugin file(aRequest);

   559 

   560 		TUint mode = 0;

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

   562 		iLastError = err;

   563 		iLineNumber = __LINE__;

   564 		if(err!=KErrNone)

   565 			return err;

   566 

   567 		err = file.Replace(filename, mode);

   568 		iLastError = err;

   569 		iLineNumber = __LINE__;

   570 		if(err!=KErrNone)

   571 			return err;

   572 		

   573 		//we have replace/opened our file, now lets write to it.

   574 		

   575 		TBuf8<64> writeData;

   576 		writeData.FillZ(64);

   577 		writeData.Copy(_L8("0123456789"));

   578 		err = file.Write(0, writeData, 10);

   579 		iLastError = err;

   580 		iLineNumber = __LINE__;

   581 		if(err!=KErrNone)

   582 			return err;

   583 		

   584 		//Now lets EFsFileReplace another file

   585 		TFileName secondName;

   586 		secondName.Append(testfilename1);

   587 		RFilePlugin file2(aRequest);

   588 		err = file2.Replace(secondName, mode);

   589 		iLastError = err;

   590 		iLineNumber = __LINE__;

   591 		if(err!=KErrNone)

   592 			return err;

   593 		

   594 		//Now lets write to it.

   595 		TBuf8<64> writeData2;

   596 		writeData2.FillZ(64);

   597 		writeData2.Copy(_L8("9876543210"));

   598 		err = file2.Write(0,writeData2,10);

   599 		iLastError = err;

   600 		iLineNumber = __LINE__;

   601 		if(err!=KErrNone)

   602 			return err;

   603 		

   604 		//Now lets open another file.

   605 		TFileName thirdFile;

   606 		thirdFile.Append(testfilename2);

   607 		err = rfs.Delete(thirdFile);

   608 		if(err == KErrNotFound)

   609 			err = KErrNone;

   610 		iLastError = err;

   611 		iLineNumber = __LINE__;

   612 		if(err!=KErrNone)

   613 			return err;

   614 

   615 		RFilePlugin file3(aRequest);

   616 		err = file3.Create(thirdFile, EFileWrite);

   617 		iLastError = err;

   618 		iLineNumber = __LINE__;

   619 		if(err!=KErrNone)

   620 			return err;

   621 		

   622 		//Now lets write to it.

   623 		TBuf8<64> writeData3;

   624 		writeData3.FillZ(64);

   625 		writeData3.Copy(_L8("3333333333"));

   626 		err = file3.Write(0,writeData3,10);

   627 		iLastError = err;

   628 		iLineNumber = __LINE__;

   629 		if(err!=KErrNone)

   630 			return err;

   631 		

   632 		// Now we need to read the data and make sure that the correct data is in the correct files,

   633 		// this check probably needs to be checked from RFile/test_harness as well.

   634 		TBuf8<64> readData3;

   635 		readData3.SetLength(10);

   636 		err = file3.Read(0, readData3, 10);

   637 		iLastError = err;

   638 		iLineNumber = __LINE__;

   639 		if(err!=KErrNone)

   640 			return err;

   641 			

   642 		err = readData3.Compare(writeData3);

   643 		if(err != KErrNone)

   644 			{

   645 			iLastError = err;

   646 			iLineNumber = __LINE__;

   647 			return err;

   648 			}

   649 		

   650 		//close file 3

   651 		file3.Close();

   652 		

   653 		// read from file2

   654 		TBuf8<64> readData2;

   655 		readData2.SetLength(10);

   656 		err = file2.Read(0, readData2, 10);

   657 		iLastError = err;

   658 		iLineNumber = __LINE__;

   659 		if(err!=KErrNone)

   660 			return err;

   661 		

   662 		err = readData2.Compare(writeData2);

   663 		if(err != KErrNone)

   664 			{

   665 			iLastError = err;

   666 			iLineNumber = __LINE__;

   667 			return err;

   668 			}

   669 		

   670 		//close file 2

   671 		file2.Close();

   672 		

   673 		// read from file1

   674 		TBuf8<64> readData1;

   675 		readData1.SetLength(10);

   676 		err = file.Read(0, readData1, 10);

   677 		iLastError = err;

   678 		iLineNumber = __LINE__;

   679 		if(err!=KErrNone)

   680 			return err;

   681 		

   682 		err = readData1.Compare(writeData);

   683 		if(err != KErrNone)

   684 			{

   685 			iLastError = err;

   686 			iLineNumber = __LINE__;

   687 			return err;

   688 			}

   689 

   690 		file.TransferToClient();

   691 

   692 		rfs.Close();

   693 		

   694 		return KErrCompletion;

   695 	

   696 		}

   697 	return err;

   698 	}

   699 

   700 

   701 CFsPluginConn* CCombinationalPlugin::NewPluginConnL()

   702 	{

   703 	return new(ELeave) CCombinationalPluginConn();

   704 	}

   705 

   706 

   707 //Synchronous RPlugin::DoControl

   708 TInt CCombinationalPlugin::FsPluginDoControlL(CFsPluginConnRequest& aRequest)

   709 	{	

   710 	TInt err = KErrNone;

   711 

   712 	//We can use this to set the drive

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

   714 	TInt function = aRequest.Function();

   715 	TPckg<TChar> drive(iDriveToTest);

   716 	typedef TBuf<256> TDirName;

   717 	TPckg<TDirName> dirnamePckg(iDirFullName);

   718 	TPckg<TInt> errCodeDes(iLastError);

   719 	TPckg<TInt> lineNumberDes(iLineNumber);

   720 	

   721 	switch(function)

   722 		{

   723 		case KPluginSetDrive:

   724 			{

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

   726 			break;

   727 			}

   728 		case KPluginSetDirFullName:

   729 			{

   730 			//This is necessary as at present we have nwo way of getting the name of

   731 			//a directory!

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

   733 			break;

   734 			}

   735 		case KPluginGetError:

   736 			{

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

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

   739 			break;

   740 			}

   741 		default:

   742 			break;

   743 		}

   744 

   745 	return err;

   746 	}

   747 

   748 

   749 TInt CCombinationalPluginConn::DoControl(CFsPluginConnRequest& aRequest)

   750 	{

   751 	return ((CCombinationalPlugin*)Plugin())->FsPluginDoControlL(aRequest);

   752 	}

   753 

   754 void CCombinationalPluginConn::DoRequest(CFsPluginConnRequest& aRequest)

   755 	{

   756 	DoControl(aRequest);

   757 	}

   758 

   759 void CCombinationalPluginConn::DoCancel(TInt /*aReqMask*/)

   760 	{

   761 	}

   762 

   763 

   764 

   765 //factory functions

   766 

   767 class CCombinationalPluginFactory : public CFsPluginFactory

   768 	{

   769 public:

   770 	CCombinationalPluginFactory();

   771 	virtual TInt Install();			

   772 	virtual CFsPlugin* NewPluginL();

   773 	virtual CFsPlugin* NewPluginConnL();

   774 	virtual TInt UniquePosition();

   775 	};

   776 

   777 /**

   778 Constructor for the plugin factory

   779 @internalComponent

   780 */

   781 CCombinationalPluginFactory::CCombinationalPluginFactory()

   782 	{

   783 	}

   784 

   785 /**

   786 Install function for the plugin factory

   787 @internalComponent

   788 */

   789 TInt CCombinationalPluginFactory::Install()

   790 	{

   791 	SetSupportedDrives(KPluginSupportAllDrives);

   792 	return(SetName(&KCombinationalPluginName));

   793 	}

   794 

   795 /**

   796 @internalComponent

   797 */

   798 TInt CCombinationalPluginFactory::UniquePosition()

   799 	{

   800 	return(KCombinationalPos);

   801 	}

   802 

   803 /**

   804 Plugin factory function

   805 @internalComponent

   806 */

   807 CFsPlugin* CCombinationalPluginFactory::NewPluginL()

   808 

   809 	{

   810 	return CCombinationalPlugin::NewL();

   811 	}

   812 

   813 /**

   814 Plugin factory function

   815 @internalComponent

   816 */

   817 CFsPlugin* CCombinationalPluginFactory::NewPluginConnL()

   818 

   819 	{

   820 	return CCombinationalPlugin::NewL();

   821 	}

   822 

   823 /**

   824 Create a new Plugin

   825 @internalComponent

   826 */

   827 extern "C" {

   828 

   829 EXPORT_C CFsPluginFactory* CreateFileSystem()

   830 	{

   831 	return(new CCombinationalPluginFactory());

   832 	}

   833 }

   834
Symaptic