1 // Copyright (c) 2003-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 #include "commands.h"

    17 #include <biodb.h>

    18 #include <bitsids.h>

    19 #include <biouids.h>

    20 #include <miutset.h>

    21 #include <pop3set.h>

    22 #include <imapset.h>

    23 #include <smtpset.h>

    24 #include <smutset.h>

    25 #include <mtmdef.h>

    26 #include <regpsdll.h>

    27 

    28 #include <cmsvattachment.h>

    29 #include <mmsvattachmentmanager.h>

    30 #include <cemailaccounts.h>

    31 

    32 #ifdef SYMBIAN_BOOKMARK_DATABASE

    33 #include <bookmarkdatabase.h>

    34 #include <bookmark.h>

    35 _LIT(KTxtBookmarkExtension, ".ebm");

    36 #endif // SYMBIAN_BOOKMARK_DATABASE

    37 

    38 #include <commsdat.h>

    39 #include <utf.h>

    40 #include <cdblen.h>

    41 

    42 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

    43 #include "tmsvbioinfo.h"

    44 #endif

    45 

    46 //

    47 // CDoCmdGeneral

    48 // Handles the running of the genral commands

    49 

    50 //

    51 // For ECmdGeneralComment

    52 CDoCmdGeneral* CDoCmdGeneral::NewL(CClientTestHarness& aTestHarness, const CDesCArrayFlat& aComment, TCmdGeneral aCmd)

    53 {

    54 	CDoCmdGeneral* self = NULL;

    55 

    56 	switch(aCmd)

    57 	{

    58 		case(ECmdGeneralComment):

    59 		{

    60 			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralComment);

    61 			CleanupStack::PushL(self);

    62 			self->ConstructL(aComment);

    63 			CleanupStack::Pop(self);

    64 		}

    65 		break;

    66 

    67 		case(ECmdGeneralCheckUsedBif):

    68 		{

    69 			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralCheckUsedBif);

    70 			CleanupStack::PushL(self);

    71 			self->ConstructL(aComment);

    72 			CleanupStack::Pop(self);

    73 		}

    74 		break;

    75 

    76 		case(ECmdGeneralCheckFileWithExtExists):

    77 		{

    78 			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralCheckFileWithExtExists);

    79 			

    80 		}

    81 		break;

    82 

    83 		case(ECmdGeneralPrettifyLog):

    84 		{

    85 			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralPrettifyLog);

    86 		}

    87 		break;

    88 

    89 		case(ECmdGeneralDumpMsg):

    90 		{

    91 			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralDumpMsg);

    92 		}

    93 		break;

    94 

    95 		case(ECmdGeneralGenerateFromFile):

    96 		{

    97 			self = new (ELeave) CDoCmdGeneral(aTestHarness, ECmdGeneralGenerateFromFile);

    98 			CleanupStack::PushL(self);

    99 			self->ConstructL(aComment);

   100 			CleanupStack::Pop(self);

   101 		}

   102 		break;

   103 

   104 		default:

   105 			User::Leave(KErrNotFound);

   106 	}

   107 	

   108 	return self;

   109 }

   110 

   111 //

   112 // For ECmdGeneralComment

   113 void CDoCmdGeneral::ConstructL(const CDesCArrayFlat& aComment)

   114 {

   115 	switch(iCmd)

   116 	{

   117 		case(ECmdGeneralComment):

   118 		{

   119 			TInt commentSize = 0;

   120 			for(TInt i = 0; i < aComment.Count(); i++)

   121 				commentSize += ((aComment[i]).Length() + _L(" ").Size());

   122 

   123 			iComment = HBufC::NewL(commentSize);

   124 			TPtr commentPtr = iComment->Des();

   125 

   126 			for(TInt j = 0; j < aComment.Count(); j++)

   127 			{

   128 				commentPtr.Append((aComment)[j]);

   129 				commentPtr.Append(_L(" "));

   130 			}

   131 		}

   132 		break;

   133 

   134 		case(ECmdGeneralGenerateFromFile):

   135 		case(ECmdGeneralCheckUsedBif):

   136 		{

   137 			TBuf<KMaxFileName> mFilename;

   138 			mFilename = aComment[0];

   139 			iComment=mFilename.AllocL();

   140 		}

   141 		break;

   142 

   143 		default:

   144 			break;

   145 	}

   146 }

   147 

   148 //

   149 // For ECmdGenerateFromSection

   150 CDoCmdGeneral* CDoCmdGeneral::NewL(CClientTestHarness& aTestHarness, const HBufC*& aBuffer, const TBIOMessageType& aMsgType, TCmdGeneral aCmd)

   151 {

   152 	CDoCmdGeneral* self = new (ELeave) CDoCmdGeneral(aTestHarness, aCmd);

   153 	CleanupStack::PushL(self);

   154 	self->ConstructL(aBuffer, aMsgType);

   155 	CleanupStack::Pop(self);

   156 	return self;

   157 }

   158 

   159 void CDoCmdGeneral::ConstructL(const HBufC*& aBuffer, const TBIOMessageType& aMsgType)

   160 {

   161 	//

   162 	// Must make local copy of buffer;

   163 	iBuffer = HBufC::NewMaxL(aBuffer->Length());

   164 	*iBuffer = *aBuffer;

   165 	iMsgType = aMsgType;

   166 }

   167 

   168 //

   169 // For others

   170 CDoCmdGeneral* CDoCmdGeneral::NewL(CClientTestHarness& aTestHarness, TCmdGeneral aCmd)

   171 {

   172 	CDoCmdGeneral* self = new (ELeave) CDoCmdGeneral(aTestHarness, aCmd);

   173 	return self;

   174 }

   175 

   176 void CDoCmdGeneral::StartL(TRequestStatus& aStatus)

   177 {

   178 	switch(iCmd)

   179 	{

   180 		case ECmdGeneralPrettifyLog:

   181 			PrettifyLogL();

   182 			break;

   183 		case ECmdGeneralDumpMsg:

   184 			DumpCurrentMessageL();

   185 			break;

   186 		case ECmdGeneralClean:

   187 			{

   188 			iTestHarness.TestUtils().CleanMessageFolderL();

   189 			}

   190 			break;

   191 		case ECmdGeneralComment:

   192 		{

   193 			//

   194 			// Now we have to add the debugging line number which we only know at run time...

   195 			TBuf<7> commentString;

   196 			commentString.Format(_L("[%4d] "), iDebugInfo.LineNumber());

   197 

   198 			//

   199 			// Create a pointer to the HBufC, realloc size and then insert new data...

   200 			iComment = iComment->ReAllocL(iComment->Size() + commentString.Size());

   201 			TPtr commentPtr = iComment->Des();

   202 			commentPtr.Insert(0, commentString);

   203 			iTestHarness.TestUtils().WriteComment(*iComment);

   204 			break;

   205 		}

   206 		case ECmdGeneralGenerateFromFile:

   207 			{

   208 			GenerateBIOMessageFromFileL(*iComment);

   209 			}

   210 			break;

   211 		case ECmdGeneralGenerateFromSection:

   212 			GenerateBIOMessageFromSectionL();

   213 			break;

   214 		case ECmdGeneralCheckUsedBif:

   215 			CheckBifFileUsedL(*iComment);

   216 			break;

   217 		case ECmdGeneralCheckFileWithExtExists:

   218 			CheckDataFileCreatedL();

   219 			break;

   220 		case ECmdGeneralCleanAllBioMsgs:

   221 			CleanAllBioMsgsL();

   222 			break;

   223 

   224 		default:

   225 			User::Leave(KErrNotFound);

   226 	}

   227 

   228 	//

   229 	// We leave on error, so always say KErrNone

   230 	TRequestStatus* req = &aStatus;

   231 	User::RequestComplete(req, KErrNone);

   232 

   233 }

   234 

   235 CDoCmdGeneral::~CDoCmdGeneral()

   236 {

   237 	delete iBuffer;

   238 	delete iComment;

   239 }

   240 

   241 

   242 void CDoCmdGeneral::PrettifyLogL()

   243 {

   244 	TParse loglocation;

   245 	TFileName logfile;

   246 	User::LeaveIfError(iTestHarness.TestUtils().ResolveLogFile(KNullDesC, loglocation));

   247 	logfile.Copy(loglocation.FullName());

   248 	logfile.Delete(logfile.Length()-1,1);

   249 	iTestHarness.TestUtils().DoAppendVariantName(logfile);

   250 

   251 	RFile Lfile;

   252 	Lfile.Open(g_rfs,logfile,EFileRead|EFileShareAny);

   253 

   254 	_LIT(KHTMLExtn,".html");

   255 	logfile.Append(KHTMLExtn);

   256 	RFile Hfile;

   257 	User::LeaveIfError(Hfile.Replace(g_rfs,logfile,EFileWrite|EFileShareAny));

   258 

   259 	_LIT8(KHTMLHeader,"<HTML><HEAD><TITLE>TBIO_T Test Logfile</TITLE></HEAD><BODY><PRE>\n\r");

   260 	_LIT8(KHTMLFooter,"</PRE></BODY>");

   261 	_LIT8(KHTMLRedLineStart,"<FONT COLOR=red>");

   262 	_LIT8(KHTMLGreenLineStart,"<FONT COLOR=green>");

   263 	_LIT8(KHTMLBlackLineStart,"<FONT COLOR=c0c0c0>");

   264 	_LIT8(KHTMLBlueLineStart,"<FONT COLOR=blue>");

   265 	_LIT8(KHTMLLineEnd,"</FONT><br>");

   266 			

   267 	Hfile.Write(KHTMLHeader);

   268 

   269 	TBuf8<258> mReadBuf; //258 = KMaxLogLineLength + '\n\r'

   270 	

   271 	TInt p=0;

   272 	Lfile.Read(mReadBuf);

   273 	while(mReadBuf.Length()>0)

   274 	{

   275 		TInt eol = mReadBuf.Locate('\n');

   276 		p+=eol+1;  //skip the \r

   277 		Lfile.Seek(ESeekStart,p);

   278 		if (eol>0)

   279 		{

   280 			mReadBuf.SetLength(eol); //skip the \n

   281 

   282 			_LIT8(KDesOK,"ok");

   283 			_LIT8(KDesError,"error");

   284 			_LIT8(KDesFailed,"failed");

   285 			_LIT8(KDesWarning,"warning");

   286 

   287 			TBuf8<20> linestart;

   288 			

   289 			linestart = KHTMLBlackLineStart;		

   290 

   291 			if (mReadBuf.FindF(KDesOK())>0)

   292 			{

   293 				linestart=KHTMLGreenLineStart;

   294 			}

   295 			else if (mReadBuf.FindF(KDesError())>0)

   296 			{

   297 				linestart=KHTMLRedLineStart;

   298 			}

   299 			else if (mReadBuf.FindF(KDesFailed())>0)

   300 			{

   301 				linestart=KHTMLRedLineStart;

   302 			}

   303 			else if (mReadBuf.FindF(KDesWarning())>0)

   304 			{

   305 				linestart=KHTMLBlueLineStart;

   306 			}

   307 

   308 			Hfile.Write(linestart);

   309 			Hfile.Write(mReadBuf);

   310 			Hfile.Write(KHTMLLineEnd);

   311 		}

   312 

   313 		Lfile.Read(mReadBuf);

   314 	}

   315 

   316 	Hfile.Write(KHTMLFooter);

   317 	

   318 	Hfile.Close();

   319 	Lfile.Close();

   320 }

   321 

   322 void CDoCmdGeneral::CheckBifFileUsedL(TDesC& aExpectedName)

   323 {

   324 	// Checks that the Message Type Uid is correct

   325 	// NB - this will change to check the BIF Name when the

   326 	// base source code has been updated to support it.

   327 	iTestHarness.InstantiateClientMtmL();

   328 

   329 	const TMsvId& mMsg = iTestHarness.CurrentBioMsg();

   330 

   331 	iTestHarness.TestUtils().iMsvEntry->SetEntryL(mMsg);

   332 

   333 	TMsvEntry tm = iTestHarness.TestUtils().iMsvEntry->Entry();

   334 	TInt mBioMsgInt = tm.iBioType;

   335 	TUid mBioMsgUID = TUid::Uid(mBioMsgInt);

   336 

   337 	TBuf<32> description;

   338 	TUid mMessageTypeUid;

   339 	TInt index;

   340 	

   341 	CBIODatabase* bioDB = CBIODatabase::NewLC(g_rfs);

   342 	bioDB->GetBioIndexWithMsgIDL(mBioMsgUID, index);

   343 

   344 	description.Copy(bioDB->BifReader(index).Description());

   345 	mMessageTypeUid=bioDB->BifReader(index).MessageTypeUid();

   346 

   347 	CleanupStack::PopAndDestroy();	// bioDB

   348 

   349 	TBuf<32> mUidHexString;

   350 	_LIT(KHexFormatString,"%x");

   351 	mUidHexString.Format(KHexFormatString,mMessageTypeUid);

   352 

   353 	if (mUidHexString.CompareF(aExpectedName)!=0)

   354 	{

   355 		_LIT(KTmp,"ERROR - checking BIF MessageTypeUID - expected \"%S\" read \"%S\"");

   356 		HBufC* td = HBufC::NewLC(KTmp().Length()+105);

   357 		td->Des().Format(KTmp,&aExpectedName,&mUidHexString);

   358 		iTestHarness.TestUtils().WriteComment(*td);

   359 		CleanupStack::PopAndDestroy(td);

   360 

   361 		User::Leave(KErrGeneral); //Test framework requires us to leave if test fails

   362 	}

   363 	else

   364 	{

   365 		_LIT(KOK,"OK Checked BIF FileTypeUid - correct");

   366 		iTestHarness.TestUtils().WriteComment(KOK);

   367 	}

   368 }

   369 

   370 #ifdef SYMBIAN_BOOKMARK_DATABASE

   371 void CDoCmdGeneral::CheckBookmarksDbL() const

   372 	{

   373 	iTestHarness.TestUtils().WriteComment(_L("-- BookmarkDb Details --"));

   374 	RBkDatabase bookmarkDb;

   375 	bookmarkDb.OpenL();

   376 	CleanupClosePushL(bookmarkDb);

   377 	RBkFolder rootFolder = bookmarkDb.OpenRootL();

   378 	CleanupClosePushL(rootFolder);

   379 	RBkNode bookmarkItem;

   380 	TBool foundBookmark = EFalse;

   381 	const TInt bookmarkCount = rootFolder.Count();

   382 	for( TInt ii=0; ii<bookmarkCount; ++ii )

   383 		{

   384 		bookmarkItem = rootFolder.OpenItemL(ii);

   385 		CleanupClosePushL(bookmarkItem);

   386 		if( bookmarkItem.Type() == Bookmark::ETypeBookmark )

   387 			{

   388 			foundBookmark = ETrue;

   389 			Bookmark::TItemId bookmarkId = bookmarkItem.Id();

   390 			CleanupStack::PopAndDestroy(&bookmarkItem);

   391 			

   392 			// bookmark found, display bookmark infomation

   393 			RBkBookmark bookmark = bookmarkDb.OpenBookmarkL(bookmarkId);

   394 			CleanupClosePushL(bookmark);

   395 			TBuf<Bookmark::KMaxUriLength> uri;

   396 			uri.Copy(bookmark.Uri());

   397 			iTestHarness.TestUtils().WriteComment(bookmark.Title());

   398 			iTestHarness.TestUtils().WriteComment(uri);

   399 			CleanupStack::PopAndDestroy(&bookmark);

   400 			iTestHarness.TestUtils().WriteComment(_L("-----"));

   401 			}

   402 		else

   403 			{

   404 			CleanupStack::PopAndDestroy(&bookmarkItem);

   405 			}

   406 		}

   407 		

   408 	CleanupStack::PopAndDestroy(2, &bookmarkDb);	// rootFolder, bookmarkDb

   409 	

   410 	if( !foundBookmark )

   411 		{

   412 		_LIT(KError,"ERROR - No bookmarks found in root folder of BookmarkDb.");

   413 		iTestHarness.TestUtils().WriteComment(KError);

   414 		User::Leave(KErrNotFound);

   415 		}

   416 	}

   417 #endif // SYMBIAN_BOOKMARK_DATABASE

   418 

   419 void CDoCmdGeneral::CheckDataFileCreatedL()

   420 {

   421 	iTestHarness.InstantiateClientMtmL();

   422 

   423 	const TMsvId& messageId = iTestHarness.CurrentBioMsg();

   424 

   425 	iTestHarness.TestUtils().iMsvEntry->SetEntryL(messageId);

   426 

   427 	TInt index;

   428 

   429 	TMsvEntry tm = iTestHarness.TestUtils().iMsvEntry->Entry();

   430 	TInt mBioMsgInt = tm.iBioType;

   431 	TUid mBioMsgUID = TUid::Uid(mBioMsgInt);

   432 	

   433 	CBIODatabase* bioDB = CBIODatabase::NewLC(g_rfs);

   434 	bioDB->GetBioIndexWithMsgIDL(mBioMsgUID, index);

   435 

   436 	TBuf<KMaxFileName> mExtn = bioDB->BifReader(index).FileExtension();

   437 

   438 	// The following section is necessary as semi-supported iacp functions

   439 	// (e.g. WWWHotlist) just create a file, but the bif file doesn't have

   440 	// a file extension field set.  DPS

   441 	_LIT(KNullString,"");

   442 

   443 	if (mExtn==KNullString)

   444 	{

   445 		_LIT(KNullExtensionWarning,"Warning: file extension read from BIF file is NULL!");

   446 		iTestHarness.TestUtils().WriteComment(KNullExtensionWarning);

   447 

   448 		_LIT(KWWWHotlistExtn,".eBM");

   449 

   450 		if (bioDB->BifReader(index).MessageTypeUid().iUid==KUidBIOInternetAccessPointMsg)

   451 		{

   452 			mExtn = KWWWHotlistExtn;

   453 			

   454 			_LIT(KNullFixupWarning,"Warning: As MessageTypeUid indicates IACP msg, guessed .eBM");

   455 			iTestHarness.TestUtils().WriteComment(KNullFixupWarning);

   456 		}

   457 

   458 		// The same if ture for WAPP bookmarks. See comment above.

   459 		else if (bioDB->BifReader(index).MessageTypeUid().iUid == KUidBIOWAPAccessPointMsg)

   460 		{

   461 			mExtn = KWWWHotlistExtn;

   462 			

   463 			_LIT(KNullFixupWarning,"Warning: As MessageTypeUid indicates WAPP msg, guessed .eBM");

   464 			iTestHarness.TestUtils().WriteComment(KNullFixupWarning);

   465 		}

   466 	}

   467 

   468 	CleanupStack::PopAndDestroy(bioDB);

   469 

   470 	// a <message id>.ebm attachment should exist

   471 	CMsvStore* store = iTestHarness.TestUtils().iMsvEntry->ReadStoreL();

   472 	CleanupStack::PushL(store);

   473 	MMsvAttachmentManager& manager = store->AttachmentManagerL();

   474 	TBool found = EFalse;

   475 	TBuf<KMaxFileName> ebmFilename;

   476 	ebmFilename.Format(_L("%x%S"), messageId,&mExtn);

   477 	for( TInt ii=0; ii<manager.AttachmentCount(); ++ii )

   478 		{

   479 		CMsvAttachment* attachment = manager.GetAttachmentInfoL(ii);

   480 		if( attachment->AttachmentName().CompareF(ebmFilename) == 0 )

   481 			{

   482 			found = ETrue;

   483 			}

   484 		delete attachment;

   485 		

   486 		if( found )

   487 			{

   488 			break;

   489 			}

   490 		}

   491 	CleanupStack::PopAndDestroy(store);

   492 	

   493 	TBuf<KMaxFileName+40> mOut;

   494 	if( found )

   495 		{

   496 		_LIT(KOK,"OK File Exists (%S)");

   497 		mOut.Format(KOK, &ebmFilename);

   498 		iTestHarness.TestUtils().WriteComment(mOut);

   499 		

   500 #ifdef SYMBIAN_BOOKMARK_DATABASE

   501 		// File is found, ensure that bookmarks exists is database if it

   502 		// is a bookmark file

   503 		if( mExtn.CompareF(KTxtBookmarkExtension) == 0 )

   504 			{

   505 			CheckBookmarksDbL();

   506 			}

   507 #endif // SYMBIAN_BOOKMARK_DATABASE		

   508 		}

   509 	else

   510 		{

   511 		_LIT(KError,"ERROR: File [%S] not found!");

   512 		mOut.Format(KError, &ebmFilename);

   513 		iTestHarness.TestUtils().WriteComment(mOut);

   514 

   515 		User::Leave(KErrNotFound);

   516 		}

   517 

   518 }

   519 

   520 

   521 void CDoCmdGeneral::DumpCurrentMessageL()

   522 {

   523 	_LIT(KAboutToDump,"Dump of Parsed Fields:");

   524 	iTestHarness.TestUtils().WriteComment(KAboutToDump);

   525 

   526 	iTestHarness.InstantiateClientMtmL();

   527 

   528 	const TMsvId& messageId = iTestHarness.CurrentBioMsg();

   529 	iTestHarness.TestUtils().iMsvEntry->SetEntryL(messageId);

   530 

   531 	CMsvStore* mStore = iTestHarness.TestUtils().iMsvEntry->ReadStoreL();

   532 	CleanupStack::PushL(mStore);

   533 

   534 	RMsvReadStream msgInStream;

   535 	msgInStream.OpenLC(*mStore, KUidMsvBIODataStream);

   536 	

   537 	CParsedField* parsedField = new(ELeave) CParsedField();

   538 	CleanupStack::PushL(parsedField);

   539 	

   540 	TInt numOfFields = msgInStream.ReadUint8L();

   541 	

   542 	for (TInt i = 0; i < numOfFields; i++)

   543 		{

   544 		parsedField->InternalizeL(msgInStream);

   545 

   546 		TPtrC mFieldName = parsedField->FieldName();

   547 		TPtrC mFieldVal = parsedField->FieldValue();

   548 

   549 		HBufC* td = HBufC::NewLC(10+mFieldName.Length()+mFieldVal.Length());

   550 				

   551 		_LIT(KTmp,"-- %S:\"%S\"");

   552 		td->Des().Format(KTmp,&mFieldName,&mFieldVal);

   553 

   554 		//NB this shouldn't really be needed as msgs should

   555 		//be shorter than 160 chars, but some of the test data

   556 		//aren't!!

   557 		if (td->Length()>220) {td->Des().SetLength(220);}

   558 		

   559 

   560 		iTestHarness.TestUtils().WriteComment(*td);

   561 

   562 		CleanupStack::PopAndDestroy(td);

   563 		}

   564 

   565 	CleanupStack::PopAndDestroy(parsedField);

   566 	CleanupStack::PopAndDestroy();	// msgInStream.OpenLC ??? not sure what got created...

   567 	CleanupStack::PopAndDestroy(mStore);

   568 }

   569 

   570 

   571 void CDoCmdGeneral::GenerateBIOMessageFromSectionL()

   572 {

   573 	iTestHarness.InstantiateClientMtmL();

   574 	TMsvId newEntryId = iTestHarness.TestUtils().CreateBIOEntryL(*iBuffer, iMsgType);

   575 	_LIT(KMessageGend,"Msg Generated from section with ID: (%d)");

   576 

   577 	TBuf<KMaxFileName*2> mComment;

   578 	mComment.Format(KMessageGend, newEntryId);

   579 	iTestHarness.TestUtils().WriteComment(mComment);		

   580 

   581 	//

   582 	// Set the context Biomsg to the

   583 	// entry we've just added to the

   584 	// message store

   585 	iTestHarness.SetCurrentBioMsg(newEntryId);				

   586 }

   587 

   588 

   589 void CDoCmdGeneral::GenerateBIOMessageFromFileL(const TDesC& aFilename)

   590 {

   591 	//

   592 	// Generates the BIO message we store as a member variable from a

   593 	// file.  Initially assumes file name only given (looks in default

   594 	// BIO msg directory).  If not found tries to find file based on

   595 	// aFilename being a fully qualified filename incl. path.

   596 	//

   597 	//

   598  	TBuf<KMaxFileName> currentFile;

   599 	TMsvId messageId;

   600 	TBIOMessageType currentMsgType;

   601 

   602 	currentFile = KBioTMsgDirectory;

   603 	currentFile.Append(aFilename);

   604 

   605 	TEntry mEntry;

   606 

   607 	//

   608 	// Check that file exists

   609 	TInt err=g_rfs.Entry(currentFile,mEntry);

   610 

   611 	//

   612 	// If not, try the alternate path

   613 	if(err != KErrNone)

   614 	{

   615 		currentFile = aFilename;

   616 		TInt err=g_rfs.Entry(currentFile,mEntry);

   617 		if (err!=KErrNone) User::Leave(err); //Leave (not found)

   618 	}

   619 	

   620 	//

   621 	// Set up for server side testing	

   622 //	iTestHarness.InstantiateServerMtmL();

   623 	iTestHarness.InstantiateClientMtmL();

   624 

   625 	//

   626 	// Pull the file name off

   627 	TInt nPos = currentFile.LocateReverse('\\');

   628 	TPtrC current(currentFile.Right(currentFile.Length() - nPos - 1));

   629 

   630 	//

   631 	// Get utils to set type based on file name

   632 	currentMsgType = iTestHarness.TestUtils().SetMessageType(current);

   633 

   634 	if(currentMsgType!=ENoMessage) // skip dodgy filenames

   635 	{ 

   636 		messageId = iTestHarness.TestUtils().CreateBIOEntryFromFileL( currentFile,currentMsgType);

   637 

   638 		_LIT(KMessageGend,"Msg Generated from [%S] with ID: (%d)");

   639 

   640 		TBuf<KMaxFileName*2> mComment;

   641 		mComment.Format(KMessageGend,&aFilename, messageId);

   642 		iTestHarness.TestUtils().WriteComment(mComment);		

   643 

   644 		//

   645 		// Set the context Biomsg to the

   646 		// entry we've just added to the

   647 		// message store

   648 		iTestHarness.SetCurrentBioMsg(messageId);										  

   649 	}

   650 	else

   651 	{

   652 		_LIT(KBadFileName,"Error [%S] isn't a BIO Msg Filename.");

   653 		TBuf<KMaxFileName+40> mComment;

   654 		mComment.Format(KBadFileName,&aFilename);

   655 		iTestHarness.TestUtils().WriteComment(mComment);

   656 		User::Leave(KErrNotFound);

   657 	}

   658 }

   659 

   660 

   661 void CDoCmdGeneral::CleanAllBioMsgsL()

   662 {

   663 	// Clean the BIO message entires only, marked by iMtmUid == KUidBIOMessageTypeMtm.

   664 	

   665 	// Go client side.

   666 	iTestHarness.InstantiateClientMtmL();

   667 

   668 	// Access the context.

   669 	CMsvEntry& entry = *(iTestHarness.TestUtils().iMsvEntry);

   670 

   671 	// Change context to root folder.

   672 	entry.SetEntryL(KMsvRootIndexEntryId);

   673 

   674 	// Set the msg selection ordering.

   675 	TMsvSelectionOrdering ordering;

   676 	ordering.SetShowInvisibleEntries(ETrue);

   677 	entry.SetSortTypeL(ordering);

   678 

   679 	// Delete all email accounts from CenRep

   680 	CEmailAccounts* accounts = CEmailAccounts::NewLC();

   681 	

   682 	// delete POP accounts

   683 	RArray<TPopAccount> popAccounts;

   684 	CleanupClosePushL(popAccounts);

   685 	accounts->GetPopAccountsL(popAccounts);

   686 	TInt count = popAccounts.Count();

   687 	for(TInt ii=0; ii<count; ++ii)

   688 		{

   689 		accounts->DeletePopAccountL(popAccounts[ii]);

   690 		}

   691 	CleanupStack::PopAndDestroy(&popAccounts);

   692 	

   693 	// delete IMAP accounts

   694 	RArray<TImapAccount> imapAccounts;

   695 	CleanupClosePushL(imapAccounts);

   696 	accounts->GetImapAccountsL(imapAccounts);

   697 	count = imapAccounts.Count();

   698 	for(TInt ii=0; ii<count; ++ii)

   699 		{

   700 		accounts->DeleteImapAccountL(imapAccounts[ii]);

   701 		}

   702 	CleanupStack::PopAndDestroy(&imapAccounts);

   703 	

   704 	// delete SMTP accounts

   705 	RArray<TSmtpAccount> smtpAccounts;

   706 	CleanupClosePushL(smtpAccounts);

   707 	accounts->GetSmtpAccountsL(smtpAccounts);

   708 	count = smtpAccounts.Count();

   709 	for(TInt ii=0; ii<count; ++ii)

   710 		{

   711 		accounts->DeleteSmtpAccountL(smtpAccounts[ii]);

   712 		}

   713 	CleanupStack::PopAndDestroy(&smtpAccounts);

   714 	

   715 	CleanupStack::PopAndDestroy(accounts);

   716 	

   717 	entry.SetEntryL(KMsvGlobalInBoxIndexEntryId);

   718 	entry.SetEntryL(KMsvRootIndexEntryId);

   719 

   720 	// Check each service.

   721 	CMsvEntrySelection* services = entry.ChildrenWithTypeL(KUidMsvServiceEntry);

   722 	CleanupStack::PushL(services);

   723 

   724 	TInt serviceCount = services->Count();

   725 	

   726 	if(serviceCount)

   727 		{

   728 		for(TInt i = 0; i < serviceCount; i++)

   729 			{

   730 			entry.SetEntryL(services->At(i));    

   731 

   732 			// BIO services do not contain folders, so can be deleted.

   733 			if (entry.Entry().iMtm == KUidBIOMessageTypeMtm)

   734 				{

   735 				entry.SetEntryL(KMsvRootIndexEntryId);

   736 				entry.DeleteL(services->At(i));

   737 				}

   738 

   739 			// Check each folder within other services.

   740 			else

   741 				{

   742 				CMsvEntrySelection* folders = entry.ChildrenWithTypeL(KUidMsvFolderEntry);

   743 				CleanupStack::PushL(folders);

   744 

   745 				TInt fldrCount = folders->Count();

   746 

   747 				if (fldrCount)

   748 					{

   749 					for (TInt ii = 0; ii < fldrCount; ii++)

   750 						{

   751 						entry.SetEntryL(folders->At(ii));

   752 

   753 						// Check each messaging in the folder.

   754 						CMsvEntrySelection* msgs = entry.ChildrenWithTypeL(KUidMsvMessageEntry);

   755 						CleanupStack::PushL(msgs);

   756 

   757 						TInt msgCount = msgs->Count();

   758 

   759 						if(msgCount)

   760 							{

   761 							for(TInt iii = 0; iii < msgCount; iii++)

   762 								{

   763 								// Delete if BIO message.

   764 								TMsvEntry	msgEntry = entry.ChildDataL(msgs->At(iii));

   765 

   766 								if (msgEntry.iMtm == KUidBIOMessageTypeMtm)

   767 									entry.DeleteL(msgs->At(iii));

   768 								}

   769 							}

   770 						CleanupStack::PopAndDestroy(msgs);

   771 						}

   772 					}

   773 				CleanupStack::PopAndDestroy(folders);

   774 				}

   775 			}

   776 		}

   777 	CleanupStack::PopAndDestroy(services);

   778 

   779 	// Reset context back to root folder.

   780 	entry.SetEntryL(KMsvRootIndexEntryId);

   781 }

   782 

   783 //

   784 // CDoCmdBioDB

   785 // Handles the running of the genral commands

   786 

   787 //

   788 // Constants

   789 const TUid KUidBioMsgTypeEmailNotification = {0x10005530};

   790 const TUid KUidBioMsgTypeVCal = {0x10005533};

   791 

   792 //

   793 // For others

   794 CDoCmdBioDB* CDoCmdBioDB::NewL(CClientTestHarness& aTestHarness, TCmdBioDB aCmd)

   795 {

   796 	CDoCmdBioDB* self = new (ELeave) CDoCmdBioDB(aTestHarness, aCmd);

   797 	return self;

   798 }

   799 

   800 void CDoCmdBioDB::StartL(TRequestStatus& aStatus)

   801 {

   802 	switch(iCmd)

   803 	{

   804 		case ECmdBioDBDump:

   805 			DoBioDBDumpL();

   806 			break;			

   807 

   808 		case ECmdBioDBTestAPI:

   809 			DoBioDBTestAPIL();

   810 			break;

   811 

   812 		case ECmdBioDBDumpWapBif:

   813 			DoBioDBDumpWapBifsL();

   814 			break;

   815 

   816 		case ECmdBioDBCheckBioness:

   817 			DoBioDBCheckBionessL();

   818 			break;

   819 

   820 		case ECmdBioDBDefaultSendBearer:

   821 			DoBioDBDefaultSendBearerL();

   822 			break;

   823 

   824 		default:

   825 			User::Leave(KErrNotFound);

   826 	}

   827 

   828 	//

   829 	// We leave on error, so always say KErrNone

   830 	TRequestStatus* req = &aStatus;

   831 	User::RequestComplete(req, KErrNone);

   832 }

   833 

   834 void CDoCmdBioDB::DoBioDBDumpL()

   835 {

   836 	_LIT(KTestStart, "Starting BIODB BIF Dump...");

   837 	iTestHarness.TestUtils().WriteComment(KTestStart);

   838 

   839 	HBufC* commentText = HBufC::NewLC(100);

   840 	CBIODatabase* bioDB = CBIODatabase::NewL(g_rfs);

   841 	CleanupStack::PushL(bioDB);

   842 

   843 	(commentText->Des()).Format(_L("%D Bif files read\n"), bioDB->BIOCount());

   844 	iTestHarness.TestUtils().WriteComment(*commentText);

   845 

   846 	const CArrayFix<TBioMsgId>* ent = NULL;

   847 	

   848 	for (TInt i=0; i < bioDB->BIOCount(); i++)

   849 	{

   850 		const CBioInfoFileReader& bifReader = bioDB->BifReader(i);

   851 		TPtrC desc;

   852 		desc.Set(bifReader.Description());

   853 		(commentText->Des()).Format(_L("%D: '%S'"), i, &desc);

   854 		iTestHarness.TestUtils().WriteComment(*commentText);

   855 		ent = bioDB->BIOEntryLC(i);

   856 		CleanupStack::PopAndDestroy();		//ent

   857 	}

   858 	

   859 	_LIT(KLookForWap, "\r\nLooking for all Wap Ports to Watch\n");

   860 	iTestHarness.TestUtils().WriteComment(KLookForWap);

   861 	TPtrC desc;

   862 	TInt pos;

   863 	ent = bioDB->BioEntryByTypeLC(CBIODatabase::EStart, EBioMsgIdWap, pos);

   864 	

   865 	while(pos < bioDB->BIOCount())

   866 	{

   867 		desc.Set(bioDB->BifReader(pos).Description());

   868 		

   869 		for (TInt i = 0; ent && i < ent->Count(); i++)

   870 		{

   871 			if ((*ent)[i].iType == EBioMsgIdWap)

   872 			{

   873 				(commentText->Des()).Format(_L("%D: '%S' Port#:%D"), i, &desc, (*ent)[i].iPort);

   874 				iTestHarness.TestUtils().WriteComment(*commentText);

   875 			}

   876 		}

   877 		if(ent != NULL)

   878 			CleanupStack::PopAndDestroy();	// ent

   879 		

   880 		ent = bioDB->BioEntryByTypeLC(CBIODatabase::ENext, EBioMsgIdWap, pos);

   881 	}

   882 	if(ent != NULL)

   883 		CleanupStack::PopAndDestroy();	// ent

   884 

   885 	_LIT(KLookNBS, "\nLooking for all NBS Ports to Watch\n");

   886 	iTestHarness.TestUtils().WriteComment(KLookNBS);

   887 	

   888 	ent = bioDB->BioEntryByTypeLC(CBIODatabase::EStart, EBioMsgIdNbs, pos);

   889 	

   890 	while(pos < bioDB->BIOCount())

   891 	{

   892 		desc.Set(bioDB->BifReader(pos).Description());

   893 		

   894 		for (TInt i = 0; ent && i < ent->Count(); i++)

   895 		{

   896 			if ((*ent)[i].iType == EBioMsgIdNbs)

   897 			{

   898 				(commentText->Des()).Format(_L("%D: '%S' String:%S"), i, &desc, &((*ent)[i].iText));

   899 				iTestHarness.TestUtils().WriteComment(*commentText);

   900 			}

   901 		}

   902 		if (ent != NULL)

   903 			CleanupStack::PopAndDestroy();	// ent

   904 

   905 		ent = bioDB->BioEntryByTypeLC(CBIODatabase::ENext, EBioMsgIdNbs, pos);

   906 	}

   907 	if (ent != NULL)

   908 		CleanupStack::PopAndDestroy();	// ent

   909 	

   910 	CleanupStack::PopAndDestroy(bioDB);

   911 	CleanupStack::PopAndDestroy(commentText);

   912 

   913 	_LIT(KTestEnd, "Done BIODB BIF Dump");

   914 	iTestHarness.TestUtils().WriteComment(KTestEnd);

   915 }

   916 

   917 void CDoCmdBioDB::DoBioDBTestAPIL()

   918 {

   919 	_LIT(KTestStart, "Starting BIODB TestAPI...");

   920 	iTestHarness.TestUtils().WriteComment(KTestStart);

   921 

   922 	TUid msgID;

   923 

   924 	CBIODatabase* bioDB = CBIODatabase::NewL(g_rfs);

   925 	CleanupStack::PushL(bioDB);

   926 

   927 	while(bioDB->BIOCount())

   928 	{

   929 		bioDB->GetBioMsgID(0,msgID);

   930 		bioDB->RemoveBifL(msgID);

   931 	}

   932 

   933 	_LIT(KTestEnd, "Done BIODB TestAPI");

   934 	iTestHarness.TestUtils().WriteComment(KTestEnd);

   935 	CleanupStack::PopAndDestroy(bioDB);

   936 }

   937 

   938 void CDoCmdBioDB::DoBioDBDumpWapBifsL()

   939 {

   940 	//

   941 	// Gets a list of port numbers for WAP Port type

   942 	TInt pos;

   943 	HBufC* commentText = HBufC::NewLC(100);

   944 	CBIODatabase* bioDB = CBIODatabase::NewL(g_rfs);

   945 	CleanupStack::PushL( bioDB );

   946 	

   947 	_LIT(KTestStart, "Starting BIODB WAP BIF Dump...");

   948 	iTestHarness.TestUtils().WriteComment(KTestStart);

   949 

   950 	const CArrayFix<TBioMsgId>* bioMsgIDs = bioDB->BioEntryByTypeLC(

   951 							CBIODatabase::EStart,

   952 							EBioMsgIdWap, pos);

   953 	while(bioMsgIDs != NULL)

   954 	{

   955 		TUid msgUID;

   956 

   957 		bioDB->GetBioMsgID(pos, msgUID);

   958 

   959 		_LIT(KMFormatString, "<%S>:\tBioUID %D\tParserName %S\tFile Extension %S");

   960 

   961 		TFileName parserName(bioDB->GetBioParserNameL(msgUID));

   962 

   963 		TPtrC ext;

   964 		ext.Set(bioDB->GetFileExtL(msgUID));

   965 

   966 		TPtrC desc;

   967 		desc.Set(bioDB->BifReader(pos).Description());

   968 		(commentText->Des()).Format(KMFormatString, &desc, msgUID, &parserName, &ext);

   969 		iTestHarness.TestUtils().WriteComment(commentText->Des());

   970 

   971 		for (TInt i = 0; i < bioMsgIDs->Count(); i++)

   972 		{

   973 			TBuf<100> bearerString;

   974 			GetBearerText(bioMsgIDs->At(i).iType, bearerString);

   975 			(commentText->Des()).Format(_L("\t\tType:%S\tConf:%D\tIANA:%S\tPort:%D\t"),

   976 					&bearerString,

   977 					bioMsgIDs->At(i).iConfidence,

   978 					&(bioMsgIDs->At(i).iText),

   979 					bioMsgIDs->At(i).iPort);

   980 			

   981 			iTestHarness.TestUtils().WriteComment(commentText->Des());

   982 		}

   983 		

   984 		CleanupStack::PopAndDestroy();	// bioMsgID

   985 		

   986 		bioMsgIDs = bioDB->BioEntryByTypeLC(

   987 							CBIODatabase::ENext,

   988 							EBioMsgIdWap, pos);

   989 	}

   990 

   991 

   992 	TInt portNumber = 0;

   993 	TRAP_IGNORE(bioDB->GetPortNumberL(KUidBioMsgTypeEmailNotification, EBioMsgIdWap, portNumber));

   994 	

   995 

   996 	_LIT(KFormat, "Email Notify is Wap Port %d");

   997 	(commentText->Des()).Format(KFormat,portNumber);

   998 	iTestHarness.TestUtils().WriteComment(commentText->Des());

   999 

  1000 	TBioMsgIdText ianaString;

  1001 	TRAP_IGNORE(bioDB->GetIdentifierTextL(KUidBioMsgTypeEmailNotification, EBioMsgIdIana, ianaString));

  1002 	

  1003 	_LIT(KFormat2, "Email Notify is IANA String %d");

  1004 	(commentText->Des()).Format(KFormat2, &ianaString);

  1005 	iTestHarness.TestUtils().WriteComment(commentText->Des());

  1006 	

  1007 	CleanupStack::PopAndDestroy(bioDB);

  1008 	CleanupStack::PopAndDestroy(commentText);

  1009 

  1010 	_LIT(KTestEnd, "Done BIODB WAP BIF Dump");

  1011 	iTestHarness.TestUtils().WriteComment(KTestEnd);

  1012 }

  1013 

  1014 void CDoCmdBioDB::DoBioDBCheckBionessL()

  1015 {

  1016 	CBIODatabase* bioDB = CBIODatabase::NewL(g_rfs);

  1017 	CleanupStack::PushL(bioDB);

  1018 

  1019 	/*	Not finished, and not used by parser.

  1020 		Keeping, unsure of history, GL 29_05_03.

  1021 	TBioMsgId bioMsg = iTestHarness.CurrentBioMsg();

  1022 	TUid bioMsgId;

  1023 

  1024 	_LIT(KIsBio, "This IS a BIO message");

  1025 	_LIT(KIsntBio, "This IS NOT a BIO message");

  1026 

  1027 	if(bioDB->IsBioMessageL(bioMsg, bioMsgId) == KErrNone)

  1028 	{

  1029 		iTestHarness.TestUtils().WriteComment(KIsBio);

  1030 	}

  1031 	else

  1032 	{

  1033 		iTestHarness.TestUtils().WriteComment(KIsntBio);

  1034 	}

  1035 	*/

  1036 	CleanupStack::PopAndDestroy(bioDB);

  1037 }

  1038 

  1039 void CDoCmdBioDB::DoBioDBDefaultSendBearerL()

  1040 {

  1041 	HBufC* commentText = HBufC::NewLC(100);

  1042 	TBuf<100> bearerString;

  1043 	CBIODatabase* bioDB = CBIODatabase::NewL(g_rfs);

  1044 	CleanupStack::PushL( bioDB );

  1045 	

  1046 	_LIT(KEmailFound, "Default Send Bearer for EmailNotifciation %S (%d)\n");

  1047 	_LIT(KEmailNotFound, "Default Send Bearer for EmailNotifciation cannot be found\n");

  1048 	_LIT(KUnexpected, "Unexepect Error %d");

  1049 

  1050 	TBioMsgId aBioMsgIdentifier;

  1051 	TRAPD(err, bioDB->GetDefaultSendBearerL(KUidBioMsgTypeEmailNotification, aBioMsgIdentifier));

  1052 	if (!err)

  1053 	{

  1054 		GetBearerText(aBioMsgIdentifier.iType, bearerString);

  1055 		(commentText->Des()).Format(KEmailFound ,&bearerString, aBioMsgIdentifier.iType);

  1056 	}

  1057 	else if (err == KErrNotFound)

  1058 	{

  1059 		(commentText->Des()).Format(KEmailNotFound);

  1060 	}

  1061 	else 

  1062 	{

  1063 		(commentText->Des()).Format(KUnexpected, err);

  1064 	}

  1065 

  1066 	iTestHarness.TestUtils().WriteComment(commentText->Des());

  1067 

  1068 

  1069 	_LIT(KVCalFound, "Default Send Bearer for KUidBioMsgTypeVCal %S (%d)\n");

  1070 	_LIT(KVCalNotFound, "Default Send Bearer for KUidBioMsgTypeVCal cannot be found\n");

  1071 

  1072 	TBioMsgIdType aPortType = EBioMsgIdWap;

  1073 	TRAP( err, bioDB->GetDefaultSendBearerTypeL(KUidBioMsgTypeVCal, aPortType));

  1074 	if (!err)

  1075 	{

  1076 		GetBearerText(aPortType, bearerString);

  1077 		(commentText->Des()).Format(KVCalFound ,&bearerString, aPortType);;

  1078 	}

  1079 	else if (err == KErrNotFound)

  1080 	{

  1081 		(commentText->Des()).Format(KVCalNotFound);

  1082 	}

  1083 	else 

  1084 	{

  1085 		(commentText->Des()).Format(KUnexpected, err);

  1086 	}

  1087 	

  1088 	iTestHarness.TestUtils().WriteComment(commentText->Des());

  1089 	

  1090 

  1091 	_LIT(KVCardNotFound, "Default Send Bearer for KUidBioMsgTypeVCard cannot be found\n");

  1092 	

  1093 	TRAP(err, bioDB->GetDefaultSendBearerByTypeL(KUidBioMsgTypeEmailNotification, EBioMsgIdWapSecure, aBioMsgIdentifier));

  1094 	if (!err) 

  1095 	{

  1096 		(commentText->Des()).Format(KVCardNotFound,aBioMsgIdentifier.iPort);

  1097 	

  1098 	}

  1099 	else if (err == KErrNotFound)

  1100 	{

  1101 		(commentText->Des()).Format(KVCardNotFound);

  1102 	}

  1103 	else

  1104 	{

  1105 		(commentText->Des()).Format(KUnexpected, err);

  1106 	}

  1107 		

  1108 	iTestHarness.TestUtils().WriteComment(commentText->Des());

  1109 

  1110 

  1111 	CleanupStack::PopAndDestroy();	// bioDB

  1112 	CleanupStack::PopAndDestroy();	// commentText

  1113 }

  1114 

  1115 CDoCmdBioDB::~CDoCmdBioDB()

  1116 {

  1117 }

  1118 

  1119 void CDoCmdBioDB::GetBearerText(TInt aBearer, TBuf<100>& rBearerString)

  1120 {

  1121 	switch (aBearer)

  1122 	{

  1123 	case EBioMsgIdIana:

  1124 		rBearerString.Copy(_L("Iana"));

  1125 		break;

  1126 	case EBioMsgIdNbs:

  1127 		rBearerString.Copy(_L("Nbs"));

  1128 		break;

  1129 	case EBioMsgIdWap:

  1130 		rBearerString.Copy(_L("Wap"));

  1131 		break;

  1132 	case EBioMsgIdWapSecure:

  1133 		rBearerString.Copy(_L("WapSecure"));

  1134 		break;