1 // Copyright (c) 2004-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 "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 /**

    17  @file

    18  @released

    19 */

    20 

    21 #include "t_burteststepbase.h"

    22 

    23 namespace bur_ts

    24 	{

    25 	_LIT(KTabText, "\t|");

    26 	_LIT(KFormatText2, "%S%S");

    27 	_LIT(KFormatText3, "%S%S%S");

    28 	_LIT(KFormatText4, "%S%S%d");

    29 	_LIT(KFormatText5, "%S%S%X");

    30 	_LIT(KFormatText6, "%S%S%s");

    31 	

    32 	const TUint8 KMaxHexLength = 8;

    33 	

    34 	CBURTestStepBase::CBURTestStepBase(CBURTestServer& aParent) 

    35 		/**

    36 		C++ Constructor

    37 		

    38 		@internalComponent

    39 		@released

    40 		

    41 		@param aParent - The parent CBURTestServer of this child test step.

    42 		*/

    43 		:iParentTestServer(aParent),

    44 		iBackupClient(NULL),

    45 		iBackupIncType(EBackupBase),

    46 	 	iIsPartial(EFalse),

    47 	 	iExpectStatus(1),

    48 	 	iExpectStatus2(1),

    49 		iFailures(KErrNone),

    50 		iStorageManager(NULL),

    51 		iMode(EBackupMode),

    52 		iWaitedForActive(EFalse)

    53 		{}

    54 	

    55 	CBURTestStepBase::~CBURTestStepBase()

    56 		/**

    57 		C++ Destructor

    58 		@internalComponent

    59 		@released

    60 		*/

    61 		{

    62 		iDataOwners.ResetAndDestroy();

    63 		iDataOwners.Close();

    64 			

    65 		iSidArray.Close();

    66 		iJidArray.Close();

    67 		iPublicFileNames.Close();

    68 		iPrivateFileNames.Close();

    69 		iPrivateFileSizes.Close();

    70 		

    71 		iFs.Close();

    72 		

    73 		iTransferTypes.ResetAndDestroy();

    74 		iTransferTypes.Close();

    75 		

    76 		delete iStorageManager;

    77 		delete iActiveScheduler;

    78 		

    79 		delete iBackupClient;

    80 		}

    81 	

    82 	// LOGGING METHODS

    83 	void CBURTestStepBase::Log(TUint aIndentationLevel, const TDesC& aLog)

    84 		/**

    85 		Logs the data inside the string as text string at aIndentationLevel.

    86 		

    87 		@internalComponent

    88 		@released

    89 		

    90 		@param aIndentationLevel - The indentation level in the TestExecute test report.

    91 		@param aLog - The message to be logged.

    92 		*/

    93 		{

    94 		HBufC* indentation = NULL;

    95 		indentation = GetIndentation(aIndentationLevel);

    96 		TPtr ptr = indentation->Des();

    97 		INFO_PRINTF3(KFormatText2, &ptr, &aLog);

    98 		delete indentation;

    99 		}

   100 	

   101 	void CBURTestStepBase::LogWithText(TUint aIndentationLevel, const TDesC& aLog, const TDesC& aText)

   102 		/**

   103 		Writes the message with a text string.

   104 		

   105 		@internalComponent

   106 		@released

   107 		

   108 		@param aIndentationLevel - The indentation level in the TestExecute test report.

   109 		@param aLog - The message to be logged.

   110 		@param aText - Textual data to be logged with the main message.

   111 		*/

   112 		{

   113 		HBufC* indentation = NULL;

   114 		indentation = GetIndentation(aIndentationLevel);

   115 		TPtr ptr = indentation->Des();

   116 		INFO_PRINTF4(KFormatText3, &ptr, &aLog, &aText);

   117 		delete indentation;

   118 		}

   119 	

   120 	void CBURTestStepBase::LogWithText8(TUint aIndentationLevel, const TDesC& aLog, const TDesC8& aText)

   121 		/**

   122 		8-bit variant of the above

   123 		

   124 		@internalComponent

   125 		@released

   126 		

   127 		@param aIndentationLevel - The indentation level in the TestExecute test report.

   128 		@param aLog - The message to be logged.

   129 		@param aText - 8-bit textual data to be logged with the main message.

   130 		*/

   131 		{

   132 		HBufC* indentation = NULL;

   133 		indentation = GetIndentation(aIndentationLevel);

   134 		TPtr ptr = indentation->Des();

   135 		INFO_PRINTF4(KFormatText3, &ptr, &aLog, &aText);

   136 		delete indentation;

   137 		}

   138 	

   139 	void CBURTestStepBase::LogWithNum(TUint aIndentationLevel, const TDesC& aLog, TInt aNum)

   140 		/**

   141 		Writes to the report a number along with a message.

   142 		

   143 		@internalComponent

   144 		@released

   145 		

   146 		@param aIndentationLevel - The indentation level in the TestExecute test report.

   147 		@param aLog - The message to be logged.

   148 		@param aNum - Number to be printed with the log.

   149 		*/

   150 		{

   151 		HBufC* indentation = NULL;

   152 		indentation = GetIndentation(aIndentationLevel);

   153 		TPtr ptr = indentation->Des();

   154 		INFO_PRINTF4(KFormatText4, &ptr, &aLog, aNum);

   155 		delete indentation;

   156 		}

   157 	

   158 	void CBURTestStepBase::LogWithSID(TUint aIndentationLevel, const TDesC& aLog, TSecureId aSecureId)

   159 		/**

   160 		Writes out a TSecureId as a hexadecimal number along with a message.

   161 		

   162 		@internalComponent

   163 		@released

   164 		

   165 		@param aIndentationLevel - The indentation level in the TestExecute test report.

   166 		@param aLog - The message to be logged.

   167 		@param aSecureId - A TSecureId to be printed as a hexadecimal number.

   168 		*/

   169 		{

   170 		HBufC* indentation = NULL;

   171 		indentation = GetIndentation(aIndentationLevel);

   172 		TPtr ptr = indentation->Des();

   173 		INFO_PRINTF4(KFormatText5, &ptr, &aLog, aSecureId.iId);

   174 		delete indentation;

   175 		}

   176 	

   177 	void CBURTestStepBase::LogWithChar(TUint aIndentationLevel, const TDesC& aLog, TChar aChar)

   178 		/**

   179 		@internalComponent

   180 		@released

   181 		

   182 		@param aIndentationLevel - The indentation level in the TestExecute test report.

   183 		@param aLog - The message to be logged.

   184 		@param aChar - A single char, appended at the end of the message.

   185 		*/

   186 		{

   187 		HBufC* indentation = NULL;

   188 		indentation = GetIndentation(aIndentationLevel);

   189 		TPtr ptr = indentation->Des();

   190 		INFO_PRINTF4(KFormatText6, &ptr, &aLog, &aChar);

   191 		delete indentation;

   192 		}

   193 	

   194 	HBufC* CBURTestStepBase::GetIndentation(TInt aLevel)

   195 		/**

   196 		Generates a string of indentation markers (based on KIndentationMarker) the 

   197 		level of depth specified by aLevel

   198 		

   199 		@internalComponent

   200 		@released

   201 		

   202 		@param aLevel - Level of depth required for indentation.

   203 		*/

   204 		{

   205 		HBufC* hbuf = NULL;

   206 		

   207 		// Indentation level times the length of the indentation marker, 

   208 		// plus room for a tab and a '|'

   209 		TInt indentationLength = aLevel * KIndentationMarker().Length() + 10;

   210 		hbuf = HBufC::NewL(indentationLength);

   211 		

   212 		hbuf->Des().Append(KTabText);

   213 		for(TInt i = 0; i < aLevel; ++i)

   214 			{

   215 			hbuf->Des().Append(KIndentationMarker);

   216 			}

   217 		

   218 		return hbuf;

   219 		}

   220 	

   221 	void CBURTestStepBase::CreateStorageManagerL()

   222 		/**

   223 		Must only be called after the user input has been processed.

   224 		@internalComponent

   225 		@released

   226 		*/

   227 		{

   228 		iStorageManager = CStorageManager::NewL(iBackupDirName, iDriveList, this);

   229 		}

   230 	

   231 	void CBURTestStepBase::ProcessUserOptionsL()

   232 		/**

   233 		This function uses TestExecute config file parsers to read in the user preferences

   234 		from ini files

   235 		

   236 		@internalComponent

   237 		@released

   238 		 */

   239 		{

   240 		TPtrC backupDir;

   241 		TInt isPartial = 0;

   242 		TInt isBase = 0;

   243 		TPtrC driveListText;

   244 		

   245 		// directory for archiving backup data

   246 		_LIT(KBackupDirText1, "BackupDir");

   247 		GetStringFromConfig(ConfigSection(), KBackupDirText1, backupDir);

   248 		

   249 		_LIT(KBackupDirText2, "Backup directory: ");

   250 		LogWithText(LOG_LEVEL3, KBackupDirText2, backupDir);

   251 		iBackupDirName.Copy(backupDir);

   252 		

   253 		// affected drives

   254 		_LIT(KDriveListText1, "DriveList");

   255 		GetStringFromConfig(ConfigSection(), KDriveListText1, driveListText);

   256 		_LIT(KDriveListText2, "Drives: ");

   257 		

   258 		LogWithText(LOG_LEVEL3, KDriveListText2, driveListText);

   259 		// extract all drives from the user input

   260 		iDriveList = CBURTestStepBase::StringToDriveListL(driveListText);

   261 		

   262 		// create the storage handler based on the drives and backup directory

   263 		CreateStorageManagerL();

   264 		

   265 		_LIT(KExpectStatusText1, "ExpectStatus");

   266 		GetIntFromConfig(ConfigSection(), KExpectStatusText1, iExpectStatus);

   267 		

   268 		_LIT(KExpectStatusText2, "ExpectStatus: ");

   269 		LogWithNum(LOG_LEVEL3, KExpectStatusText2, iExpectStatus);		

   270 		

   271 		_LIT(KExpectStatusText3, "ExpectStatus2");

   272 		GetIntFromConfig(ConfigSection(), KExpectStatusText3, iExpectStatus2);

   273 		

   274 		_LIT(KExpectStatusText4, "ExpectStatus2: ");

   275 		LogWithNum(LOG_LEVEL3, KExpectStatusText4, iExpectStatus2);			

   276 

   277 		// full/partial backup

   278 		_LIT(KPartialText1, "IsPartial");

   279 		GetIntFromConfig(ConfigSection(), KPartialText1, isPartial);

   280 		if (isPartial == 0)

   281 			{

   282 			iIsPartial = EFalse;

   283 			

   284 			_LIT(KPartialText2, "Full/Partial Type: Full");

   285 			Log(LOG_LEVEL3, KPartialText2);

   286 			} //if

   287 		else if (isPartial == 1)

   288 			{

   289 			iIsPartial = ETrue;

   290 			TSecureId sid;

   291 			

   292 			TChar ch;

   293 			TPtrC list;

   294 			

   295 			

   296 			// PARSING ID LIST //

   297 			

   298 			_LIT(KSIDList, "IDs");

   299 			GetStringFromConfig(ConfigSection(), KSIDList, list);

   300 			TLex sidLex(list);

   301 		

   302 			while (!sidLex.Eos())

   303 				{

   304         		sidLex.Mark();

   305 	        	ch=sidLex.Peek();

   306 

   307     	    	while(!sidLex.Eos() && ( ch=sidLex.Peek() ) != TChar(','))

   308         			sidLex.Inc();

   309  

   310         		if(!sidLex.TokenLength())

   311         			continue;

   312         		

   313         		TPtrC pToken = sidLex.MarkedToken();

   314         		TLex token(pToken);

   315         		

   316         		if (pToken.Length() <= KMaxHexLength && token.Val(sid.iId, EHex) == KErrNone)

   317         			{

   318         			iSidArray.Append(sid);

   319 					_LIT(KFound, "ID Found in ini file: ");

   320 					LogWithSID(LOG_LEVEL4, KFound, sid);		

   321         			} //if

   322         		else // must be a Java suite hash

   323         			{

   324         			iJidArray.Append(pToken);

   325         			_LIT(KJFound, "Java ID Found in ini file: ");

   326         			LogWithText(LOG_LEVEL4, KJFound, pToken);

   327         			}

   328 				

   329         		if(ch==TChar(','))

   330         			sidLex.Inc();

   331         		

   332         		sidLex.SkipSpace();

   333         

   334 				} //while

   335 				

   336 			

   337 			_LIT(KPartialText3, "Full/Partial Type: Partial");

   338 			Log(LOG_LEVEL3, KPartialText3);

   339 			} //if

   340 		else

   341 			{

   342 			_LIT(KPartialText4, "Full/Partial Type: UNKNOWN");

   343 			_LIT(KPartialText5, "** PLEASE USE 0 OR 1 ONLY **");

   344 			_LIT(KPartialText6, "** Using FULL as default  **");

   345 			Log(LOG_LEVEL4, KPartialText4);

   346 			Log(LOG_LEVEL4, KPartialText5);

   347 			Log(LOG_LEVEL4, KPartialText6);

   348 			}

   349 		

   350 		// base/incremental

   351 		_LIT(KIncrText1, "BaseOnly");

   352 		GetIntFromConfig(ConfigSection(), KIncrText1, isBase);

   353 		if (isBase == 1)

   354 			{

   355 			iBackupIncType = EBackupBase;

   356 			

   357 			_LIT(KIncrText2, "Base/Incremental Type: Base Only");

   358 			Log(LOG_LEVEL3, KIncrText2);

   359 			}

   360 		else if (isBase == 0)

   361 			{

   362 			iBackupIncType = EBackupIncrement;

   363 			

   364 			_LIT(KIncrText3, "Base/Incremental Type: Incremental by Default");

   365 			Log(LOG_LEVEL3, KIncrText3);

   366 			}

   367 		else

   368 			{

   369 			_LIT(KIncrText4, "Base/Incremental Type: UNKNOWN");

   370 			_LIT(KIncrText5, "** PLEASE USE 0 OR 1 ONLY **");

   371 			_LIT(KIncrText6, "** Using BASE as default  **");

   372 			Log(LOG_LEVEL4, KIncrText4);

   373 			Log(LOG_LEVEL4, KIncrText5);

   374 			Log(LOG_LEVEL4, KIncrText6);

   375 			}

   376 		

   377 		TChar delimiter(',');

   378 		

   379 		/** Read public files into array */

   380 		_LIT(KExpectPublicFiles, "ExpectPublicFiles");

   381 		ReadListIntoStringArray(KExpectPublicFiles, delimiter, iPublicFileNames);

   382 		

   383 		/** Read private files into array */

   384 		_LIT(KExpectPrivateFiles, "ExpectPrivateFiles");

   385 		ReadListIntoStringArray(KExpectPrivateFiles, delimiter, iPrivateFileNames);		

   386 		

   387 		/** Read private file sizes into array */

   388 		_LIT(KExpectPrivateFileSizes, "ExpectPrivateFileSizes");

   389 		ReadListIntoIntArray(KExpectPrivateFileSizes, delimiter, iPrivateFileSizes);

   390 		}

   391 		

   392 	void CBURTestStepBase::ReadListIntoStringArray(const TDesC& aSectionName, const TChar& aDelimiter, RArray<TPtrC>& aResultList)

   393 		{

   394 		TChar ch;

   395 		TPtrC list;

   396 		GetStringFromConfig(ConfigSection(), aSectionName, list);

   397 		TLex strLex(list);

   398 		

   399 		while (!strLex.Eos())

   400 			{

   401 			strLex.Mark();

   402         	ch=strLex.Peek();

   403 

   404 	    	while( ( !strLex.Eos() ) && 

   405 	    		   ((ch=strLex.Peek()) != aDelimiter) )

   406 	    		{

   407 	    		strLex.Inc();

   408 	    		}

   409 

   410     		if(!strLex.TokenLength())

   411     			continue;

   412     		

   413     		TPtrC pToken = strLex.MarkedToken();

   414     		aResultList.Append(pToken);

   415 			

   416     		if(ch == aDelimiter)

   417     			strLex.Inc();

   418     		

   419     		strLex.SkipSpace();    

   420 			} //while		

   421 		}

   422 	

   423 	void CBURTestStepBase::ReadListIntoIntArray(const TDesC& aSectionName, const TChar& aDelimiter, RArray<TInt>& aResultList)

   424 		{

   425 		RArray<TPtrC> strList;

   426 		CleanupClosePushL(strList);

   427 		ReadListIntoStringArray(aSectionName, aDelimiter, strList);

   428 		

   429 		TInt count = strList.Count();

   430 		for (TInt i=0; i<count; ++i)

   431 			{

   432 			TInt num = 0;

   433 			TLex token(strList[i]);

   434 			if (token.Val(num) == KErrNone)

   435 				{

   436 				aResultList.Append(num);

   437 				}

   438 			}

   439 		CleanupStack::PopAndDestroy(&strList); // strList

   440 		}	

   441 	

   442 	void CBURTestStepBase::PopulateListOfDataOwnersL()

   443 		/**

   444 		Uses CSBEClient::ListOfDataOwnersL() to extract a list of data owners that have 

   445 		registred for backup and restore. Populates iDataOwners.

   446 		

   447 		@internalComponent

   448 		@released

   449 		*/

   450 		{

   451 		_LIT(KTempText1, "Getting list of data owners from device");

   452 		Log(LOG_LEVEL2,KTempText1);

   453 		

   454 		TRAPD(err, iBackupClient->ListOfDataOwnersL(iDataOwners));

   455 		if (err != KErrNone)

   456 			{

   457 			_LIT(KTempText1, "Error getting list of data owners: ");

   458 			LogWithNum(LOG_LEVEL2,KTempText1, err);

   459 			iFailures++;

   460 			}

   461 

   462 		// Log

   463 		if (iDataOwners.Count() == 0)

   464 			{

   465 			_LIT(KTempText3, "No data owners found.");

   466 			Log(LOG_LEVEL3, KTempText3);

   467 			}

   468 		else

   469 			{

   470 			_LIT(KTempText4, "Number of data owners found on device: ");

   471 			LogWithNum(LOG_LEVEL3, KTempText4, iDataOwners.Count());

   472 			}

   473 		}

   474 		

   475 	void CBURTestStepBase::PopulateListOfDataOwnersAsyncL()

   476 		/**

   477 		Uses CSBEClient::ListOfDataOwnersL() to extract a list of data owners that have 

   478 		registred for backup and restore. Populates iDataOwners.

   479 		

   480 		@internalComponent

   481 		@released

   482 		*/

   483 		{

   484 		_LIT(KTempText1, "Getting list of data owners from device");

   485 		Log(LOG_LEVEL2,KTempText1);

   486 		CBURActiveObject* active = CBURActiveObject::NewL();

   487 		CleanupStack::PushL(active);

   488 		TRAPD(err, iBackupClient->ListOfDataOwnersL(iDataOwners, active->iStatus));

   489 		if (err == KErrNone)

   490 			{

   491 			active->StartL();

   492 			}

   493 			

   494 		if (err != KErrNone || active->Error() != KErrNone)

   495 			{

   496 			_LIT(KTempText1, "Error getting list of data owners: ");

   497 			LogWithNum(LOG_LEVEL2,KTempText1, err);

   498 			iFailures++;

   499 			}

   500 		CleanupStack::PopAndDestroy(active);

   501 		

   502 		// Log

   503 		if (iDataOwners.Count() == 0)

   504 			{

   505 			_LIT(KTempText3, "No data owners found.");

   506 			Log(LOG_LEVEL3, KTempText3);

   507 			}

   508 		else

   509 			{

   510 			_LIT(KTempText4, "Number of data owners found on device: ");

   511 			LogWithNum(LOG_LEVEL3, KTempText4, iDataOwners.Count());

   512 			}

   513 		}

   514 	

   515 	void CBURTestStepBase::SetBURModeL(TBURPartType aBURPartType, TBackupIncType aBackupIncType)

   516 		/**

   517 		Uses CSBEClient::SetBURModeL() to set backup and restore settings

   518 		

   519 		@internalComponent

   520 		@released

   521 		

   522 		@param aBURPartType - Full/Partial backup/restore.

   523 		@param aBackupIncType - Base/Incremental backup/restore.

   524 		*/

   525 		{

   526 		iBackupClient->SetBURModeL(iDriveList, aBURPartType, aBackupIncType);

   527 		}

   528 	

   529 	void CBURTestStepBase::SetBURModeAsyncL(TBURPartType aBURPartType, TBackupIncType aBackupIncType)

   530 		/**

   531 		Uses CSBEClient::SetBURModeL() Asyncrhonous version to set backup and restore settings

   532 		

   533 		@internalComponent

   534 		@released

   535 		

   536 		@param aBURPartType - Full/Partial backup/restore.

   537 		@param aBackupIncType - Base/Incremental backup/restore.

   538 		*/

   539 		{

   540 		CBURActiveObject* active = CBURActiveObject::NewL();

   541 		CleanupStack::PushL(active);

   542 		iBackupClient->SetBURModeL(iDriveList, aBURPartType, aBackupIncType, active->iStatus);

   543 		active->StartL();

   544 		User::LeaveIfError(active->Error());

   545 		CleanupStack::PopAndDestroy(active);

   546 		}

   547 	

   548 	void CBURTestStepBase::PrepareForPartialBURL()

   549 		/**

   550 		@internalComponent

   551 		@released

   552 		*/

   553 		{

   554 		TSecureId sid = NULL;

   555 		

   556 		// go through list of pids and sids

   557 		for (TInt index = 0; index < iDataOwners.Count(); index++)

   558 			{

   559 			TBool notFound = ETrue;

   560 			sid = ExtractIDL(*iDataOwners[index]);

   561 			

   562 			if (sid != NULL)

   563 				{

   564 				TInt position = iSidArray.Find(sid);

   565 				if (position != KErrNotFound)

   566 					{

   567 					_LIT(KTempText2, "ID found in list of data owners: ");

   568 					LogWithSID(LOG_LEVEL3, KTempText2, sid);

   569 					notFound = EFalse;

   570 					}

   571 				else if (position == KErrNotFound)

   572 					{

   573 					notFound = ETrue;

   574 					} // if else

   575 				} // if

   576 			else // possibly jid

   577 				{

   578 				HBufC* pSuiteHash = ExtractJavaIDL(*iDataOwners[index]);

   579 				TPtrC suiteHash = pSuiteHash->Des();

   580 				if (iJidArray.Find(suiteHash) != KErrNotFound)

   581 					{

   582 					_LIT(KTempText3, "Java ID found in list of data owners: ");

   583 					LogWithText(LOG_LEVEL3, KTempText3, suiteHash);

   584 					notFound = EFalse;

   585 					}

   586 				else // not found 

   587 					{

   588 					notFound = ETrue;

   589 					}

   590 				delete pSuiteHash;

   591 				pSuiteHash = NULL;

   592 				}

   593 			if (notFound)

   594 				{

   595 				delete iDataOwners[index];

   596 				iDataOwners[index] = NULL;

   597 				iDataOwners.Remove(index);

   598 				index--;

   599 				}

   600 			}

   601 		}

   602 		

   603 	void CBURTestStepBase::SetSIDListForPartialL()

   604 	/**

   605 	Set the list of active data owners for partial bur

   606 	

   607 	@param aDataOwners List of data owners for partial bur

   608 	*/

   609 		{

   610 		iSidArray.Reset();

   611 		for (TInt i=0; i< iDataOwners.Count(); i++)

   612 			{

   613 			if (iDataOwners[i]->CommonSettings() & EActiveBUR)

   614 				{

   615 				TSBDerivedType type = iDataOwners[i]->Identifier().DerivedTypeL();

   616 				if (type == ESIDDerivedType)

   617 					{

   618 					// means it is definately a sid

   619 					CSBSecureId* secureId = CSBSecureId::NewL(&(iDataOwners[i]->Identifier()));

   620 					CleanupStack::PushL(secureId);

   621 						

   622 					iSidArray.AppendL(secureId->SecureIdL());

   623 					CleanupStack::PopAndDestroy(secureId);

   624 					}

   625 				else if (type == EPackageDerivedType)

   626 					{

   627 					CSBPackageId* packageId = CSBPackageId::NewL(&(iDataOwners[i]->Identifier()));

   628 					CleanupStack::PushL(packageId);

   629 					

   630 					iSidArray.AppendL(packageId->SecureIdL());

   631 					CleanupStack::PopAndDestroy(packageId);

   632 					}

   633 				} //if

   634 			}// for

   635 		

   636 		// set active owners array	

   637 		TRAPD(err,iBackupClient->SetSIDListForPartialBURL(iSidArray));

   638 		if (err != KErrNone)

   639 			{

   640 			iFailures++;

   641 			_LIT(KSidP, "Error Setting list for partial : ");

   642 			LogWithNum(LOG_LEVEL3, KSidP, err);

   643 			}

   644 		}

   645 		

   646 	void CBURTestStepBase::GenerateSIDTransferTypesL(RTransferTypeArray& aTransferTypes, TTransferDataType aDataType)

   647 		/**

   648 		For each data owner in iDataOwners, this method creates CSBGenericTransferTypes

   649 		based on the TTransferDataType passed. One transfer type is created per drive that

   650 		the data owner in question has data on. Only creates transfer types supported by data owner

   651 		

   652 		@internalComponent

   653 		@released

   654 		

   655 		@param aTransferTypes - Array of transfer types.

   656 		@param aDataType - Trasnfer data type, passive base, active base, etc.

   657 		*/

   658 		{

   659 		TTransferDataType tempDataType = aDataType;

   660 		aTransferTypes.ResetAndDestroy();

   661 		TSecureId sid = NULL;

   662 		

   663 		TInt length = iDriveList.Length();

   664 		for (TInt driveCount = 0; driveCount < length; driveCount++)

   665 			{

   666 			if (iDriveList[driveCount])

   667 				{

   668 				for (TInt i = 0; i < iDataOwners.Count(); i++)

   669 					{

   670 					if ( (iDataOwners[i]->Identifier().DerivedTypeL() == ESIDDerivedType) &&

   671 					     (iDataOwners[i]->DriveList()[driveCount]) )

   672 						{

   673 						CSBSecureId* secureId = CSBSecureId::NewL(&(iDataOwners[i]->Identifier()));

   674 						CleanupStack::PushL(secureId);

   675 						

   676 						sid = secureId->SecureIdL();

   677 						

   678 						CleanupStack::PopAndDestroy(secureId);

   679 						}

   680 					else if ( (iDataOwners[i]->Identifier().DerivedTypeL() == EPackageDerivedType) &&

   681 					          (iDataOwners[i]->DriveList()[driveCount]) )

   682 						{						

   683 						CSBPackageId* pkgId = CSBPackageId::NewL(&(iDataOwners[i]->Identifier()));

   684 						CleanupStack::PushL(pkgId);

   685 					

   686 						sid = pkgId->SecureIdL();

   687 						

   688 						CleanupStack::PopAndDestroy(pkgId);	

   689 						} // else if

   690 					

   691 					if (sid != NULL)

   692 						{

   693 						// decides if data owner supports that data type

   694 						

   695 						TBool checkIfHaveBase = EFalse;

   696 						TBool baseOnly = EFalse;

   697 						TBool supports = EFalse;

   698 						switch (aDataType)

   699 							{

   700 							case ERegistrationData:

   701 								supports = EFalse;

   702 								break;

   703 							case EPassiveBaseData:

   704 								if (iDataOwners[i]->CommonSettings() & EPassiveBUR)

   705 									{

   706 									supports = ETrue;

   707 									}

   708 								break;

   709 							case EPassiveSnapshotData:

   710 								if (iDataOwners[i]->PassiveSettings() & EPassiveSupportsInc)

   711 									{

   712 									supports = ETrue;

   713 									}

   714 								break;

   715 							case EPassiveIncrementalData:

   716 								if (iDataOwners[i]->CommonSettings() & EPassiveBUR)

   717 									{

   718 									if (!(iDataOwners[i]->PassiveSettings() & EPassiveSupportsInc) && !iMode)

   719 										{

   720 										_LIT(KPsIncDt, "Base only for SID: ");

   721 										LogWithSID(LOG_LEVEL3, KPsIncDt, sid);

   722 										baseOnly = ETrue;

   723 										supports = ETrue;

   724 										aDataType = EPassiveBaseData;

   725 										}

   726 									else if (iDataOwners[i]->PassiveSettings() & EPassiveSupportsInc)

   727 										{

   728 										checkIfHaveBase = ETrue;

   729 										}

   730 									} // if

   731 								break;

   732 							case EActiveSnapshotData:

   733 								if (iDataOwners[i]->ActiveSettings() & EActiveSupportsInc)

   734 									{

   735 									supports = ETrue;

   736 									}

   737 								break;

   738 							case EActiveIncrementalData:

   739 								if (iDataOwners[i]->CommonSettings() & EActiveBUR)

   740 									{

   741 									if (!(iDataOwners[i]->ActiveSettings() & EActiveSupportsInc) && !iMode)

   742 										{

   743 										_LIT(KAcIncDt, "Base only for SID: ");

   744 										LogWithSID(LOG_LEVEL3, KAcIncDt, sid);

   745 										baseOnly = ETrue;

   746 										supports = ETrue;

   747 										aDataType = EActiveBaseData;

   748 										}

   749 									else if (iDataOwners[i]->ActiveSettings() & EActiveSupportsInc)

   750 										{

   751 										checkIfHaveBase = ETrue;

   752 										}	

   753 									} // if

   754 								break;

   755 							case EActiveBaseData:

   756 								if (iDataOwners[i]->CommonSettings() & EActiveBUR)

   757 									{

   758 									supports = ETrue;

   759 									}

   760 								break;

   761 							} //switch

   762 						

   763 						

   764 						if (checkIfHaveBase)

   765 							{

   766 							TTransferDataType dType;

   767 							if (aDataType == EActiveIncrementalData)

   768 								{

   769 								dType = EActiveBaseData;

   770 								}

   771 							else

   772 								{

   773 								dType = EPassiveBaseData;

   774 								} // if else

   775 								

   776 							CSBSIDTransferType* tType = CSBSIDTransferType::NewL(sid, TDriveNumber(driveCount), dType);

   777 							CleanupStack::PushL(tType);

   778 							TFileName fileName;

   779 							iStorageManager->GetFileNameL(tType, fileName, EFalse);

   780 							if(iStorageManager->IsFileExists(fileName))

   781 								{

   782 								supports = ETrue;

   783 								}

   784 							else 

   785 								{

   786 								_LIT(KTempText2, "No increments found use Base instead for SID: ");

   787 								LogWithSID(LOG_LEVEL3, KTempText2, sid);

   788 								supports = ETrue;

   789 								aDataType = dType;

   790 								baseOnly = ETrue;

   791 								}

   792 							CleanupStack::PopAndDestroy(tType);

   793 							} // if check if have base

   794 											

   795 						

   796 						if (supports)

   797 							{

   798 							CSBSIDTransferType* sidType = CSBSIDTransferType::NewL(sid, TDriveNumber(driveCount), aDataType);

   799 							CleanupStack::PushL(sidType);

   800 							aTransferTypes.AppendL(sidType);

   801 							CleanupStack::Pop(sidType);

   802 							} // if else

   803 						

   804 						// change to the proper dataType if base only true	

   805 						if (baseOnly)

   806 							{

   807 							aDataType = tempDataType;

   808 							}

   809 						sid = NULL;	

   810 						}// if

   811 					} // for		

   812 				} // if

   813 			} //for

   814 		}

   815 		

   816 	void CBURTestStepBase::GeneratePIDTransferTypesL(RTransferTypeArray& aTransferTypes, TPackageDataType aPkgDataType)

   817 		/**

   818 		For each data owner in iDataOwners, this method creates CSBGenericTransferTypes

   819 		based on the TTransferDataType passed. One transfer type is created per drive that

   820 		the data owner in question has data on.

   821 		

   822 		@internalComponent

   823 		@released

   824 		

   825 		@param aTransferTypes - Array of transfer types.

   826 		@param aDataType - Trasnfer data type, passive base, active base, etc.

   827 		*/

   828 		{

   829 		aTransferTypes.ResetAndDestroy();

   830 		TUid id;

   831 		//need array to avoid duplications

   832 		RArray<TUid> uidArray;

   833 		CleanupClosePushL(uidArray);

   834 		

   835 		TInt length = iDriveList.Length();

   836 		for (TInt driveCount = 0; driveCount < length; driveCount++)

   837 			{

   838 			if (iDriveList[driveCount])

   839 				{

   840 				TInt count = iDataOwners.Count();

   841 				for (TInt i = 0; i < count; i++)

   842 					{

   843 					if ( (iDataOwners[i]->Identifier().DerivedTypeL() == EPackageDerivedType) &&

   844 					     (iDataOwners[i]->DriveList()[driveCount]) )

   845 					    {

   846 					    CSBPackageId* pkgId = CSBPackageId::NewL(&(iDataOwners[i]->Identifier()));

   847 					    CleanupStack::PushL(pkgId);

   848                         

   849 					    id = pkgId->PackageIdL();

   850 					    if (uidArray.Find(id) == KErrNotFound)

   851 					        {

   852 					        CSBPackageTransferType* idType = CSBPackageTransferType::NewL(id, TDriveNumber(driveCount), aPkgDataType);

   853 					        CleanupStack::PushL(idType);

   854 					        aTransferTypes.AppendL(idType);

   855 					        CleanupStack::Pop(idType);

   856 					        //add to uid array

   857 					        uidArray.AppendL(id);

   858 					        }

   859 					    CleanupStack::PopAndDestroy(pkgId); 					    

   860 					    }

   861 					} //for		

   862 				} //if	

   863 			} //for

   864 		CleanupStack::PopAndDestroy(&uidArray);

   865 		}

   866 		

   867 	void CBURTestStepBase::GenerateJavaTransferTypesL(RTransferTypeArray& aTransferTypes, TJavaTransferType aJavaTransferType)

   868 		/**

   869 		For each data owner in iDataOwners, this method creates CSBGenericTransferTypes

   870 		based on the TTransferDataType passed. One transfer type is created per drive that

   871 		the data owner in question has data on.

   872 		

   873 		@internalComponent

   874 		@released

   875 		

   876 		@param aTransferTypes - Array of transfer types.

   877 		@param aJavaTransferType - Trasnfer data type

   878 		*/

   879 		{

   880 		aTransferTypes.ResetAndDestroy();

   881 		

   882 		TInt length = iDriveList.Length();

   883 		for (TInt driveCount = 0; driveCount < length; driveCount++)

   884 			{

   885 			if (iDriveList[driveCount])

   886 				{

   887 				TInt count = iDataOwners.Count();

   888 				for (TInt i=0; i < count; i++)

   889 					{

   890 					if ( (iDataOwners[i]->Identifier().DerivedTypeL() == EJavaDerivedType) &&

   891 					     (iDataOwners[i]->DriveList()[driveCount]) )

   892 					    {

   893 					    if ((aJavaTransferType == EJavaMIDlet && (iDataOwners[i]->CommonSettings() & EHasSystemFiles)) || aJavaTransferType == EJavaMIDletData)

   894 					        {

   895 					        CSBJavaId* javaId = CSBJavaId   ::NewL(&(iDataOwners[i]->Identifier()));

   896 					        CleanupStack::PushL(javaId);

   897 					        const TDesC& suiteHash = javaId->SuiteHashL();

   898 					        CSBJavaTransferType* javaType = CSBJavaTransferType::NewL(suiteHash, TDriveNumber(driveCount), aJavaTransferType);

   899 					        CleanupStack::PushL(javaType);

   900 					        aTransferTypes.AppendL(javaType);

   901 					        CleanupStack::Pop(javaType);

   902 					        CleanupStack::PopAndDestroy(javaId);

   903 					        }//if					    

   904 					    }

   905 					} //for

   906 				} // if

   907 			} // for

   908 		}

   909 		

   910 	

   911 	void CBURTestStepBase::GeneratePublicTransferTypesL(RPointerArray<CSBGenericDataType>& aTransferTypes)

   912 		/**

   913 		For each data owner in iDataOwners, this method creates CSBGenericTransferTypes

   914 		based on the TTransferDataType passed. One transfer type is created per drive that

   915 		the data owner in question has data on.

   916 		

   917 		@internalComponent

   918 		@released

   919 		

   920 		@param aTransferTypes - Array of transfer types.

   921 		@param aDataType - Trasnfer data type, passive base, active base, etc.

   922 		*/

   923 		{

   924 		aTransferTypes.ResetAndDestroy();

   925 

   926 		TInt count = iDataOwners.Count();

   927 		for (TInt i = 0; i < count; i++)

   928 			{

   929 			switch (iDataOwners[i]->Identifier().DerivedTypeL())

   930 				{

   931 				case EPackageDerivedType:

   932 				case ESIDDerivedType:

   933 					if (iDataOwners[i]->PassiveSettings() & EHasPublicFiles)

   934 						{

   935 						const TDesC8& desc = iDataOwners[i]->Identifier().Externalise();

   936 						CSBGenericDataType* idType = CSBGenericDataType::NewL(desc);

   937 						CleanupStack::PushL(idType);

   938 						aTransferTypes.AppendL(idType);

   939 						CleanupStack::Pop(idType);

   940 						} //if

   941 					break;

   942 				} // switch

   943 			}

   944 		}

   945 	

   946 	

   947 	void CBURTestStepBase::SupplyDataL(RTransferTypeArray& aTransferTypes)

   948 		/**

   949 		Retrieves data from the storage handler and supplies to the backup client for 

   950 		the given transfer type

   951 		

   952 		@internalComponent

   953 		@released

   954 		

   955 		@param aTransferTypes - Array of transfer types.

   956 		*/

   957 		{

   958 		TInt transferTypesCount = aTransferTypes.Count();

   959 		for(TInt currentIndex = 0; currentIndex < transferTypesCount; ++currentIndex)

   960 			{

   961 			TInt error;		

   962 			TInt increments = 0;

   963 			TInt incrIndex = 1;

   964 			

   965 			TSBDerivedType dataType = aTransferTypes[currentIndex]->DerivedTypeL();

   966 			

   967 			// check for incremental data

   968 			switch(dataType)

   969 				{

   970 				case ESIDTransferDerivedType:

   971 					{

   972 					CSBSIDTransferType* type = CSBSIDTransferType::NewL(aTransferTypes[currentIndex]);

   973 					CleanupStack::PushL(type);

   974 					

   975 					_LIT(KSid, "Supplying data for ID: ");

   976 					LogWithSID(LOG_LEVEL3, KSid, type->SecureIdL());

   977 					

   978 					if (type->DataTypeL() == EActiveIncrementalData || type->DataTypeL() == EPassiveIncrementalData)

   979 						{

   980 						increments = iStorageManager->TotalIncFiles(type);

   981 						if (!increments)

   982 							{

   983 							_LIT(KErrorText2, "No increments found");

   984 							Log(LOG_LEVEL4, KErrorText2);

   985 							// cleanup

   986 							CleanupStack::PopAndDestroy(type);

   987 							continue;

   988 							}

   989 						else 

   990 							{

   991 							_LIT(KIncFound, "Number of increments found: ");

   992 							LogWithNum(LOG_LEVEL4, KIncFound, increments);

   993 							} // else if

   994 						} // if

   995 					CleanupStack::PopAndDestroy(type);

   996 					}

   997 					break;

   998 				case EPackageTransferDerivedType:

   999 					{

  1000 					// package stuff

  1001 					CSBPackageTransferType* pType = CSBPackageTransferType::NewL(aTransferTypes[currentIndex]);

  1002 					CleanupStack::PushL(pType);

  1003 					_LIT(KPid, "Supplying data for Package ID: ");

  1004 					LogWithSID(LOG_LEVEL3, KPid, pType->PackageIdL());

  1005 					CleanupStack::PopAndDestroy(pType);

  1006 					}

  1007 					break;

  1008 				case EJavaTransferDerivedType:

  1009 					{

  1010 					// java stuff

  1011 					CSBJavaTransferType* jType = CSBJavaTransferType::NewL(aTransferTypes[currentIndex]);

  1012 					CleanupStack::PushL(jType);

  1013 					_LIT(KJid, "Supplying data for Java SuiteHash: ");

  1014 					LogWithText(LOG_LEVEL3, KJid, jType->SuiteHashL());

  1015 					CleanupStack::PopAndDestroy(jType);

  1016 					}

  1017 					break;

  1018 				

  1019 				} // switch

  1020 			TBool runAgain = ETrue;		

  1021 			do 

  1022 				{

  1023 				TBool finished;				

  1024 				TPtr8* bufferPtr = NULL;

  1025 				TRAP(error, bufferPtr = &iBackupClient->TransferDataAddressL());

  1026 				if (error != KErrNone)

  1027 					{

  1028 					_LIT(KErrTDA, "Error getting TransferDataAddress: ");

  1029 					LogWithNum(LOG_LEVEL4, KErrTDA, error);

  1030 					break;

  1031 					}

  1032 				TRAP(error, iStorageManager->RetrieveDataL(aTransferTypes[currentIndex], *bufferPtr, finished, incrIndex));

  1033 				if (error != KErrNone)

  1034 					{

  1035 					iStorageManager->Reset();

  1036 					if (error == KErrPathNotFound || error == KErrNotFound)

  1037 						{

  1038 						_LIT(KErrorText2, "Data doesn't exists");

  1039 						Log(LOG_LEVEL4, KErrorText2);

  1040 						}

  1041 					else

  1042 						{

  1043 						_LIT(KErrorText1, "Error reading from archive: ");

  1044 						LogWithNum(LOG_LEVEL4, KErrorText1, error);

  1045 						iFailures++;

  1046 						}

  1047 					break;

  1048 					} 

  1049 				else

  1050 					{

  1051 					_LIT(KLogBytes, "Number of bytes to send: ");

  1052 					LogWithNum(LOG_LEVEL4, KLogBytes, bufferPtr->Length());	

  1053 			

  1054 					TRAP(error, iBackupClient->SupplyDataL(*aTransferTypes[currentIndex], finished));

  1055 					if (error != KErrNone)

  1056 						{

  1057 						_LIT(KErrorText2, "Error supplying data to backup server: ");

  1058 						LogWithNum(LOG_LEVEL4, KErrorText2, error);

  1059 						if (iExpectStatus != error && iExpectStatus2 != error)

  1060 							{

  1061 							iFailures++;

  1062 							_LIT(KErrorText3, "Expect Error is: ");

  1063 							LogWithNum(LOG_LEVEL4, KErrorText3, iExpectStatus);

  1064 							}			

  1065 						break;

  1066 						}

  1067 					else

  1068 						{

  1069 						_LIT(KSuccess, "Operation finished successfully");

  1070 						Log(LOG_LEVEL4, KSuccess);

  1071 						}

  1072 					

  1073 					} // else

  1074 					

  1075 				if ((finished && !increments) || (incrIndex == increments && finished)) // if finished 

  1076 					{

  1077 					runAgain = EFalse;

  1078 					}

  1079 				else if (finished && incrIndex < increments) // is incremental data move to next increment

  1080 					{

  1081 					incrIndex++;

  1082 					runAgain = ETrue;

  1083 					}

  1084 				else 

  1085 					{

  1086 					runAgain = ETrue;

  1087 					}

  1088 				} // do

  1089 				while (runAgain);

  1090 			} // for

  1091 			

  1092 			if (!iFailures)

  1093 				{

  1094 				_LIT(KComp, "No errors found");

  1095 				Log(LOG_LEVEL3, KComp);

  1096 				}

  1097 		// Do not delete bufferPtr, as it gets deleted by the iBackupClient

  1098 		}

  1099 	

  1100 	TDriveList CBURTestStepBase::StringToDriveListL(TPtrC apText)

  1101 		/**

  1102 		@internalComponent

  1103 		@released

  1104 		

  1105 		@param apText - String that needs to be converted into a TDriveList.

  1106 		@return TDriveList with all the bytes set to 1 where a corresponding drive letter 

  1107 				was found in apText

  1108 		*/

  1109 		{

  1110 		TInt error;

  1111 		RFs fsSession;

  1112 		CleanupClosePushL(fsSession);

  1113 		error = fsSession.Connect();

  1114 		if (error != KErrNone)

  1115 			{

  1116 			User::Leave(error);

  1117 			}

  1118 		

  1119 		TUint8 str[KMaxDrives];

  1120 		for (TInt i = 0; i < KMaxDrives; ++i)

  1121 			{ 

  1122 			str[i] = 0; // Initialise to zero

  1123 			}

  1124 		

  1125 		TInt length = apText.Length();

  1126 		for (TInt i = 0; i < length; ++i)

  1127 			{

  1128 			TInt pos;

  1129 			fsSession.CharToDrive(apText.Ptr()[i], pos);

  1130 			str[pos] = 1;

  1131 			}

  1132 		

  1133 		TDriveList driveList;

  1134 		//driveList.FillZ(); // initialise to zeros