1 // Copyright (c) 2008-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 // Contains implementation of CTestUPnPManager class

    15 // Contains implemenatation of CTestUPnPManager, CUPnPObserver, CUPnPTimer, 

    16 // and CAction classes

    17 // 

    18 //

    19 

    20 #include "testupnpmanager.h"

    21 

    22 

    23 /*

    24   Constructor:

    25   @internalTechnology

    26   @test

    27 */

    28 CTestUPnPManager::CTestUPnPManager()

    29 :	CTestStep()

    30 	{

    31 	iCancelDiscovery = EFalse;

    32 	iExpectedData = EFalse;

    33 	iDiscoverySuccess = EFalse;

    34 	iNotifyCount = 0;

    35 	iPublishCount = 0;

    36 	iDescribeResponseCount = 0;

    37 	iRenewCount = 0;

    38 	iFailedNumUris = 0;

    39 	}

    40 

    41 /*

    42    Initializes all member vaiables.

    43    @param		None.

    44    @return		None.

    45 */

    46 void CTestUPnPManager::InitializeL()

    47 	{

    48 	iScheduler = new (ELeave) CActiveScheduler;

    49 	CActiveScheduler::Install(iScheduler);

    50 	}

    51 

    52 /*

    53    Destructor

    54    @internalTechnology

    55    @test

    56 */

    57 CTestUPnPManager::~CTestUPnPManager()

    58 	{

    59 	_LIT(KInfoDesctructorBegin, "Begin: In Destructor CTestUpnPanager....\n");

    60 	INFO_PRINTF1(KInfoDesctructorBegin);

    61 	if(iStringPoolMgr)

    62 		{

    63 		iStringPoolMgr->Release();

    64 		//this will tkae care of clean up of iStringPool

    65 		}

    66 	_LIT(KInfoDesctructorBegin2, "Releasing String Pool Manager....\n");

    67 	INFO_PRINTF1(KInfoDesctructorBegin2);

    68 		

    69 	CleanUpObserverArray();

    70 	iDeviceLocationArray.Close();

    71 	CleanUpResultsArray();

    72 	DescriptionSuiteCleanUp();

    73 	ScpdUriArrayCleanUp();

    74 	ControlUriArrayCleanUp();

    75 	EventUriArrayCleanUp();

    76 	CloseDiscoverer();

    77 	//#ifdef _DEBUG

    78 		ClosePublisher();

    79 		CActiveScheduler::Install(NULL); //Testing for ONB hangs

    80 		_LIT(KInfoDesctructorBegin1, "Deleting the Active Schedulers....\n");

    81 		INFO_PRINTF1(KInfoDesctructorBegin1);

    82 		delete iScheduler;

    83 		iScheduler = NULL;	

    84 	//#endif //_Debug

    85 

    86 	iPublisherObserverMap.Close();	

    87 	_LIT(KInfoDesctructorEnd, "End: ....In Destructor CTestUpnPanager\n");

    88 	INFO_PRINTF1(KInfoDesctructorEnd);

    89 	

    90 	//iConnection.Close ();

    91 	//iSocketServ.Close ();

    92 	}

    93 

    94 void CTestUPnPManager::ClosePublisher()

    95 	{

    96 	_LIT(KInfoLogFile, "ClosePublisher....\n");

    97 	INFO_PRINTF1(KInfoLogFile);

    98 	CancelPublish();

    99 	}

   100 

   101 void CTestUPnPManager::CloseDiscoverer()

   102 	{

   103 	iControlPoint.Close();

   104 	}

   105 

   106 void CTestUPnPManager::CleanUpObserverArray()

   107 	{

   108 	_LIT(KInfoLogFile, "CleanUpObserverArray....\n");

   109 	INFO_PRINTF1(KInfoLogFile);

   110 	if (iObserverArray.Count() > 0 )

   111 		{

   112 		iObserverArray.ResetAndDestroy();

   113 		}

   114 	else

   115 		{

   116 		iObserverArray.Close();

   117 		}

   118 	_LIT(KInfoLogFile1, "CleanUpObserverArray End....\n");

   119 	INFO_PRINTF1(KInfoLogFile1);

   120 	}

   121 

   122 void CTestUPnPManager::CleanUpResultsArray()

   123 	{

   124 	_LIT(KInfoLogFile, "CleanUpResultsArray....\n");

   125 	INFO_PRINTF1(KInfoLogFile);

   126 	TInt count = iResultsArray.Count();

   127 		for (TInt index(0); index < count ; index++ )

   128 			{

   129 			iResultsArray[index].Close();

   130 			}

   131 	iResultsArray.Close();

   132 	_LIT(KInfoLogFile1, "CleanUpResultsArray End....\n");

   133 	INFO_PRINTF1(KInfoLogFile1);

   134 	}

   135 

   136 void CTestUPnPManager::DescriptionSuiteCleanUp()

   137 	{

   138 	_LIT(KInfoLogFile, "DescriptionSuiteCleanUp....\n");

   139 	INFO_PRINTF1(KInfoLogFile);

   140 	TInt count = iDescriptionSuiteArray.Count();

   141 	for (TInt index(0); index < count ; index++ )

   142 		{

   143 		iDescriptionSuiteArray[index].iBaseUrl.Close();

   144 		iDescriptionSuiteArray[index].iDescription.Close();

   145 		DeleteSeriveUrlsList(index);

   146 		}

   147 	iDescriptionSuiteArray.Close();

   148 	_LIT(KInfoLogFile1, "DescriptionSuiteCleanUp End...\n");

   149 	INFO_PRINTF1(KInfoLogFile1);

   150 	}

   151 

   152 void CTestUPnPManager::ScpdUriArrayCleanUp()

   153 	{

   154 	_LIT(KInfoLogFile, "ScpdUriArrayCleanUp....\n");

   155 	INFO_PRINTF1(KInfoLogFile);

   156 	TInt count = iScpdUriArray.Count();

   157 	for (TInt index(0); index < count ; index++ )

   158 		{

   159 		iScpdUriArray[index].Close();

   160 		}

   161 	iScpdUriArray.Close();

   162 	

   163 	count = iIconUriArray.Count ();

   164 	for (TInt index(0); index < count ; index++ )

   165 		{

   166 		iIconUriArray[index].Close();

   167 		}

   168 	iIconUriArray.Close();	

   169 	

   170 	_LIT(KInfoLogFile1, "ScpdUriArrayCleanUp End....\n");

   171 	INFO_PRINTF1(KInfoLogFile1);

   172 	}

   173 

   174 void CTestUPnPManager::EventUriArrayCleanUp()

   175 	{

   176 	_LIT(KInfoLogFile, "EventUriArrayCleanUp....\n");

   177 	INFO_PRINTF1(KInfoLogFile);

   178 	TInt count = iEventUriArray.Count();

   179 	for (TInt index(0); index < count ; index++ )

   180 		{

   181 		iEventUriArray[index].Close();

   182 		}

   183 	iEventUriArray.Close();

   184 	_LIT(KInfoLogFile1, "EventUriArrayCleanUp End....\n");

   185 	INFO_PRINTF1(KInfoLogFile1);

   186 	}

   187 

   188 void CTestUPnPManager::ControlUriArrayCleanUp()

   189 	{

   190 	_LIT(KInfoLogFile, "ControlUriArrayCleanUp....\n");

   191 	INFO_PRINTF1(KInfoLogFile);

   192 	TInt count = iControlUriArray.Count();

   193 	for (TInt index(0); index < count ; index++ )

   194 		{

   195 		iControlUriArray[index].Close();

   196 		}

   197 	iControlUriArray.Close();

   198 	_LIT(KInfoLogFile1, "ControlUriArrayCleanUp End....\n");

   199 	INFO_PRINTF1(KInfoLogFile1);

   200 	}

   201 

   202 /*

   203    Implementation of CTestStep base class virtual and this is used for doing all

   204    initialisation common

   205     to derived classes here.

   206    @param  None

   207    @return TVerdict

   208  */

   209 TVerdict CTestUPnPManager::doTestStepPreambleL()

   210 	{

   211 	InitializeL();

   212 	SavePreviousLogFileL();

   213 	return CTestStep::doTestStepPreambleL();

   214 	}

   215 

   216 /*

   217  Save the previous log file...if any

   218 */

   219 void CTestUPnPManager::SavePreviousLogFileL()

   220 	{

   221 	_LIT(KInfoLogFile, "Saving Previous logs If any.... \n");

   222 	INFO_PRINTF1(KInfoLogFile);

   223 	RFs fileserv;

   224 	TInt error = fileserv.Connect();

   225 	if(!error)

   226 		{

   227 		_LIT(KlogFile, "C:\\logs\\log.txt");

   228 		_LIT(KPrefixLog, "C:\\upnplogs\\");

   229 		_LIT(KSuffix, "_UDEB");

   230 		_LIT(KExtn, ".txt");

   231 		

   232 		CFileMan* fMan = NULL;

   233 		TRAP_IGNORE(fMan = CFileMan::NewL(fileserv));

   234 		if(fMan != NULL)

   235 			{

   236 			CleanupStack::PushL(fMan);

   237 			RBuf newFileName, traceFileName ;

   238 			const TInt KTwentyFour = 24;

   239 			newFileName.Create(ConfigSection().Length() + KTwentyFour );

   240 			newFileName.Copy(KPrefixLog);

   241 			//Script file name

   242 			iScriptName.Copy(ConfigSection());

   243 			newFileName.Append(iScriptName);

   244 			newFileName.Append(KSuffix);

   245 			newFileName.Append(KExtn);

   246 			TInt error = fMan->Rename(KlogFile, newFileName);			

   247 						

   248 			if (error != KErrNone)

   249 				{

   250 				_LIT(KErrInfo, "Unable to Save Previous logs...May be NO Previous logs exist \n");

   251 				ERR_PRINTF1(KErrInfo);

   252 				}

   253 			else

   254 				{

   255 				_LIT(KSavingInfo, "<font color=0000ff><b>Saved Previous logs with File Name: <u>%S</u> </b></font> \n");

   256 				INFO_PRINTF2(KSavingInfo, &newFileName);

   257 				

   258 				//btracelog

   259 				_LIT(KBtracelogFile, "C:\\logs\\btrace.log");

   260 				_LIT(KBTrace, "btrace.log");				

   261 				traceFileName.Create(KPrefixLog().Length() + iScriptName.Length() + KBTrace().Length() );

   262 	  			traceFileName.Copy(KPrefixLog);

   263 	  			traceFileName.Append(iScriptName);

   264 	  			traceFileName.Append(KBTrace);	  			

   265 	  			error = fMan->Rename(KBtracelogFile, traceFileName);				

   266 	  			if ( error == KErrNone )

   267 		  			{

   268 		  			_LIT(KBtraceInfo, "<font color=0000ff><b>Saved Previous btrace logs with File Name: <u>%S</u> </b></font> \n");		  			

   269 					INFO_PRINTF2(KBtraceInfo, &traceFileName);

   270 		  			}				

   271 				}

   272 			CleanupStack::PopAndDestroy(fMan);

   273 			newFileName.Close();

   274 			traceFileName.Close ();

   275 			}

   276 		}

   277 	fileserv.Close();

   278 	_LIT(KInfoLogFile1, "Saving Previous logs End.... \n");

   279 	INFO_PRINTF1(KInfoLogFile1);

   280 	}

   281 

   282 /*

   283  return Script File name..if any

   284 */

   285 const TDesC& CTestUPnPManager::ScriptFileName()

   286 	{

   287 	return iScriptName;

   288 	}

   289 

   290 /*

   291    Implementation of CTestStep base class virtual and it is used for doing all

   292    after test treatment common to derived classes in here.

   293    @return TVerdict

   294  */

   295 TVerdict CTestUPnPManager::doTestStepPostambleL()

   296 	{

   297 	return CTestStep::doTestStepPostambleL();

   298 	}

   299 

   300 

   301 TVerdict CTestUPnPManager::doTestStepL()

   302 	{

   303 	SequenceOperationsL();

   304 	return TestStepResult();

   305 	}

   306 

   307 /*

   308    This function performs operations based on sequence specified in the ini file

   309    @param  None

   310    @return None

   311 */

   312 void CTestUPnPManager::SequenceOperationsL()

   313 	{

   314 	_LIT(KInfoLogFile, "SequenceOperationsL().... \n");

   315 	INFO_PRINTF1(KInfoLogFile);

   316 	RArray<TPtrC> sequenceList;

   317 	CleanupClosePushL(sequenceList);

   318 	TPtrC listOfSequences;

   319 	_LIT(KListOfSequences, "listofsequences");

   320 	GetStringFromConfig(ConfigSection(), KListOfSequences, listOfSequences);

   321 

   322 	TokenizeStringL(listOfSequences, sequenceList);

   323 	TInt numOperations = sequenceList.Count();

   324 

   325 	for(TInt i(0); i < numOperations; i++)

   326 		{

   327 		SetCurrentSection(sequenceList[i]);

   328 		PerformDesiredOperationsL(sequenceList[i]);

   329 		}

   330 	CleanupStack::PopAndDestroy(); 

   331 	_LIT(KInfoLogFile1, "SequenceOperationsL() End.... \n");

   332 	INFO_PRINTF1(KInfoLogFile1);

   333 	}

   334 

   335 void TestUtils::LoadESockL ( RSocketServ& aSocketServ, RConnection& aConnection )

   336 	{

   337 	User::LeaveIfError ( aSocketServ.Connect () );

   338 	User::LeaveIfError ( aConnection.Open ( aSocketServ ) );

   339 	TRequestStatus status;

   340 	aConnection.Start ( status );

   341 	User::WaitForRequest ( status );

   342 	User::LeaveIfError ( status.Int () );

   343 	aConnection.CancelAllInterfaceNotification ();

   344 	aConnection.CancelProgressNotification ();

   345 	aConnection.CancelServiceChangeNotification ();

   346 	aConnection.CancelAllSubConnectionNotification ();

   347 	}

   348 

   349 /*

   350    This function performs desired operations specified as a parameter

   351    @param  aOperation string representing operation to be performed

   352    @return None

   353 */

   354 void CTestUPnPManager::PerformDesiredOperationsL(const TDesC& aOperation)

   355 	{

   356 	const TInt KMatch = 0;

   357 	TPtrC operationType;

   358 	_LIT(KOperationType, "operationtype");

   359 	GetStringFromConfig(aOperation, KOperationType, operationType);

   360 	

   361 	/*if ( iConnection.SubSessionHandle () == 0 )

   362 		{

   363 		TestUtils::LoadESockL ( iSocketServ, iConnection );

   364 		}*/

   365 

   366 	if(operationType.Compare(KOpenDiscoverer) == KMatch)

   367 		{

   368 		OpenDiscovererL();

   369 		}

   370 	else if(operationType.Compare(KOpenPublisher) == KMatch)

   371 		{

   372 		OpenMultiplePublisherL();

   373 		}

   374 	else if(operationType.Compare(KDiscovery) == KMatch)

   375 		{

   376 		DiscoverL(aOperation);

   377 		}

   378 	else if(operationType.Compare(KCancelDiscover) == KMatch)

   379 		{

   380 		CancelDiscoverL(aOperation);

   381 		}

   382 	else if(operationType.Compare(KCancelDescribe) == KMatch)

   383 		{

   384 		CancelDescribeL(aOperation);

   385 		}

   386 	else if(operationType.Compare(KPublishService) == KMatch)

   387 		{

   388 		PublishServiceL(aOperation);

   389 		}

   390 	else if(operationType.Compare(KPublishDevice) == KMatch)

   391 		{

   392 		PublishDeviceL(aOperation);

   393 		}

   394 	else if(operationType.Compare(KDescribe) == 0)

   395 		{

   396 		DescribeL();

   397 		}

   398 	else if(operationType.Compare(KDescribeService) == 0)

   399 		{

   400 		DescribeServiceL();

   401 		}

   402 	else if(operationType.Compare(KSubscribe) == 0)

   403 		{

   404 		SubscribeForStateChangeNotificationsL();

   405 		}

   406 	else if(operationType.Compare(KUnsubscribe) == 0)

   407 		{

   408 		UnsubscribeForStateChangeNotificationsL(aOperation);

   409 		}

   410 	else if(operationType.Compare(KRegisterAnnouncement) == KMatch)

   411 		{

   412 		RegisterForAnnouncementsL(aOperation);

   413 		}

   414 	else if(operationType.Compare(KCancelNotify) == KMatch)

   415 		{

   416 		CancelNotifyAnnouncementL(aOperation);

   417 		}

   418 	else if(operationType.Compare(KInitiateControl) == KMatch)

   419 		{

   420 		InitiateActionL(aOperation);

   421 		}

   422 	else if ( operationType.Compare(KDescribeIcon) == KMatch)

   423 		{

   424 		DescribeIconL();

   425 		}

   426 	else if(operationType.Compare(KStartScheduler) == KMatch)

   427 		{

   428 		CActiveScheduler::Start();

   429 		}

   430 	else if(operationType.Compare(KStopScheduler) == KMatch)

   431 		{

   432 		CActiveScheduler::Stop();

   433 		}

   434 	else if(operationType.Compare(KStartTimer) == KMatch)

   435 		{

   436 		StartTimerL(aOperation);

   437 		}

   438 	else if(operationType.Compare(KPrintResults) == 0)

   439 		{

   440 		PrintAndValidateResultsL(aOperation);

   441 		}

   442 	}

   443 

   444 /*

   445    Parses a comma separated string and constructs a list out of the values

   446    @param	aString a reference to a string to be tokenized

   447    @param	aList is an out parameter to store a list of tokens in an arry

   448    @param	aSeparator is a character used to delimit the tokens

   449   */

   450 void CTestUPnPManager::TokenizeStringL(const TDesC& aString, RArray<TPtrC>& aList, TChar aSeparator)

   451 	{

   452 	TLex lexer(aString);

   453 

   454 	while(!lexer.Eos())

   455 		{

   456 		lexer.SkipSpaceAndMark();

   457 

   458 		while(!lexer.Eos() && lexer.Get() != aSeparator)

   459 			{

   460 			}

   461 

   462 		if(!lexer.Eos())

   463 			{

   464 			lexer.UnGet();

   465 			}

   466 		aList.AppendL(lexer.MarkedToken());

   467 		lexer.Inc();

   468 		}

   469 	}

   470 

   471 /*

   472    Starts a timer for a wait time and triggers CallBack function as timer expires.

   473    @param	None

   474    @return	None

   475  */

   476 void CTestUPnPManager::StartTimerL(const TDesC& aOperationType)

   477 	{

   478 	_LIT(KInfoLogFile, "StartTimerL.... \n");

   479 	INFO_PRINTF1(KInfoLogFile);

   480 	_LIT(KWaitTime,"waittime");

   481 	TInt waitTime = 0;

   482 	GetIntFromConfig(aOperationType, KWaitTime, waitTime);

   483 //	TTimeIntervalMicroSeconds32 interval(waitTime);

   484 	CUPnPTimer* timer = CUPnPTimer::NewL(this);

   485 	CleanupStack::PushL(timer);

   486 	timer->IssueRequestL(waitTime);

   487 	CActiveScheduler::Start();

   488 	CleanupStack::PopAndDestroy(timer);

   489 	_LIT(KInfoLogFile1, "StartTimerL End.... \n");

   490 	INFO_PRINTF1(KInfoLogFile1);

   491 	}

   492 

   493 /*

   494    Sets the current config section.

   495    @param	aCurrentSection - a reference string that represent current config section

   496    @return	None

   497  */

   498 void CTestUPnPManager::SetCurrentSection(const TDesC& aCurrentSection)

   499 	{

   500 	iCurrentSection = aCurrentSection;

   501 	}

   502 

   503 /*

   504    Retrieve the current config section.

   505    @param

   506    @return	Reference to current config section

   507  */

   508 TDesC& CTestUPnPManager::GetCurrentSection()

   509 	{

   510 	return	iCurrentSection;

   511 	}

   512 

   513 /*

   514 	Tests whether discovering services/devices is performing as specified in UPnP specifications.

   515 	@param		aOperationType is reference to a section name in ini file where required parameters

   516 				needs to be referred for this operation.

   517 	@return		None.

   518  */

   519 void CTestUPnPManager::DiscoverL(const TDesC& aOperationType)

   520 	{

   521 	RArray<TPtrC> serviceTypeList;

   522 	RArray<TPtrC> mxTimeList;

   523 	TPtrC listOfServiceTypes;

   524 	TPtrC listOfMxTimes;

   525 	_LIT(KListOfServiceTypes, "listofservicetypes");

   526 	_LIT(KListOfMxTimes, "listofmxtimes");

   527 	_LIT(KInfoLogFile, "DiscoverL.... \n");

   528 	INFO_PRINTF1(KInfoLogFile);

   529 	CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);

   530 	iObserverArray.Append(upnpObserver);

   531 	

   532 	RPnPParameterBundle pnpBundle;

   533 	pnpBundle.Open ();

   534 	CleanupClosePushL( pnpBundle );

   535 	pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);

   536 

   537 	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPDiscoverRequestParamSet);

   538 	if(!GetStringFromConfig(GetCurrentSection(), KListOfServiceTypes, listOfServiceTypes)

   539 			|| !GetStringFromConfig(GetCurrentSection(), KListOfMxTimes, listOfMxTimes))

   540 		{

   541 		_LIT(KErrInfo, "Problem in reading values from ini. \n Expected fields are: \n%S, \n%S \n");

   542 		ERR_PRINTF3( KErrInfo, &KListOfServiceTypes, &KListOfMxTimes );

   543 		//SetTestStepResult(EFail);

   544 		return;

   545 		}

   546 

   547 	TokenizeStringL(listOfServiceTypes, serviceTypeList);

   548 	TokenizeStringL(listOfMxTimes, mxTimeList);

   549 	TInt numUris = serviceTypeList.Count();

   550 	iFailedNumUris = serviceTypeList.Count(); //This should be of Unique Uri's count

   551 	TInt numMxs = mxTimeList.Count();

   552 	TLex responseTimeObj;

   553 	//__ASSERT_DEBUG ( numUris == numMxs, User::Panic (KDescoveryTestPanicCategory, KErrMissingURiOrResponceTime ) );

   554 	RBuf8 buf;

   555 	buf.Create(KMaxUriSize);

   556 	for(TInt i(0); i < numUris; i++)

   557 		{

   558 		CUPnPDiscoverRequestParamSet* discoverParamSet = CUPnPDiscoverRequestParamSet::NewL(pnpFamily );

   559 		buf.Copy(serviceTypeList[i]);

   560 		discoverParamSet->SetUriL( buf );

   561 		//response time

   562 		responseTimeObj.Assign(mxTimeList[i]);

   563 		TInt responseTime(0);

   564 		responseTimeObj.Val(responseTime);

   565 		discoverParamSet->SetResponseTime(responseTime);

   566 		}

   567 	buf.Close();

   568 	mxTimeList.Close();

   569 	serviceTypeList.Close();

   570 	iControlPoint.Discover(pnpBundle);

   571 

   572 	TBool delayEnabled = EFalse;

   573 	_LIT(KDelayEnabled, "delayenabled");

   574 	GetBoolFromConfig(GetCurrentSection(), KDelayEnabled, delayEnabled);

   575 

   576 	TBool SchedulerStatus = ETrue;

   577 	_LIT(KSchedulerStatus, "schedulerstart");

   578 	GetBoolFromConfig(GetCurrentSection(), KSchedulerStatus, SchedulerStatus);

   579 

   580 	if(SchedulerStatus)

   581 		{

   582 		CActiveScheduler::Start();

   583 		}

   584 

   585 	if(!IsDiscoverySuccess() && iFailedNumUris <= 0 )

   586 		{

   587 		//In Case of failure of Discovery....Trying once more to Discover.

   588 		//Retrty Discovery only if and only if All Uri's Timedout

   589 		_LIT(KInfoDiscoverRetry, "<font color=00ff00><b><u>Retrying Discovery....</u></b></font> \n");

   590 		INFO_PRINTF1(KInfoDiscoverRetry );

   591 		SetDiscoveryStatus(ETrue);

   592 		iControlPoint.Discover(pnpBundle);

   593 		if(SchedulerStatus)

   594 			{

   595 			CActiveScheduler::Start();

   596 			}

   597 		}

   598 	if(delayEnabled)

   599 		{

   600 		StartTimerL(aOperationType);

   601 		}

   602 	_LIT(KInfoLogFile1, "DiscoverL End... \n");

   603 	INFO_PRINTF1(KInfoLogFile1);

   604 	CleanupStack::PopAndDestroy( &pnpBundle );

   605 	}

   606 

   607 TBool CTestUPnPManager::IsDiscoverySuccess()

   608 	{

   609 	return iDiscoverySuccess;

   610 	}

   611 

   612 void CTestUPnPManager::SetDiscoveryStatus(TBool aSuccess)

   613 	{

   614 	_LIT(KInfoDiscoverSetStatus, "Setting iDiscoverySuccesss Flag to %d \n");

   615 	INFO_PRINTF2(KInfoDiscoverSetStatus, aSuccess );

   616 	iDiscoverySuccess = aSuccess;

   617 	}

   618 

   619 /*

   620 	Tests whether Publishing a Service/Device is performing as specified in UPnP specifications.

   621 	@param			aOperationType is reference to a section name in ini file where required parameters

   622 					needs to be referred for this operation.

   623 	@return			None.

   624  */

   625 void CTestUPnPManager::PublishServiceL (const TDesC& aOperationType)

   626 	{

   627 	_LIT(KInfoLogFile, "PublishServiceL().... \n");

   628 	INFO_PRINTF1(KInfoLogFile);

   629 	CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);

   630 	iObserverArray.Append(upnpObserver);

   631 	//To keep track of mapping between Observer and Publisher

   632 	TInt observerIndex = iObserverArray.Count() - 1;

   633 	RPnPParameterBundle pnpBundle ;

   634 	pnpBundle.Open();

   635 	

   636     CleanupClosePushL( pnpBundle );

   637     pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);

   638     RParameterFamily family = pnpBundle.CreateFamilyL(EUPnPServiceRegisterParamSet);

   639     

   640 	

   641    	CUPnPServiceRegisterParamSet* registerServiceParamSet = CUPnPServiceRegisterParamSet::NewL(family );

   642 	TPtrC serviceType;

   643 	GetStringFromConfig(aOperationType, KServiceType, serviceType);

   644 	RBuf8 serviceTypeBuf;

   645 	serviceTypeBuf.Create(serviceType.Length());

   646 	serviceTypeBuf.Copy(serviceType);

   647 

   648 	TPtrC usn;

   649 	GetStringFromConfig(aOperationType, KUSN, usn);

   650 	RBuf8 usnBuf;

   651 	usnBuf.Create(usn.Length());

   652 	usnBuf.Copy(usn);

   653 

   654 	TInt duration;

   655 	GetIntFromConfig(aOperationType, KCacheControl, duration);

   656 

   657 	TPtrC description;

   658 	GetStringFromConfig(aOperationType, KDescription, description);

   659 	RBuf8 descriptionBuf;

   660 	descriptionBuf.Create(description.Length());

   661 	descriptionBuf.Copy(description);

   662 

   663 	TInt serviceduration =  300;

   664 	GetIntFromConfig(aOperationType, KServiceMaxDuration, serviceduration);

   665 		

   666 	registerServiceParamSet->SetUriL ( serviceTypeBuf );

   667 	registerServiceParamSet->SetDeviceUidL ( usnBuf );

   668 	registerServiceParamSet->SetCacheControlData ( duration );

   669 	registerServiceParamSet->SetSubscriptionDuration(serviceduration);

   670 	

   671 	ExtractServiceDescriptionL (aOperationType, *registerServiceParamSet);

   672 

   673 	_LIT8(KInitialMessage, "Initial Service Message");

   674 	registerServiceParamSet->SetInitialMessageL(KInitialMessage);

   675 

   676 	//To keep track of mapping between Observer and Publisher

   677 	TInt publisherIndex = OpenPublisherL();

   678 	//Create mapping of Publsiher and observer

   679 	TPublisherObserverMap publisherObserverMapElement;

   680 	publisherObserverMapElement.iPublisherIndex = publisherIndex;

   681 	publisherObserverMapElement.iObserverIndex =  observerIndex;

   682 	publisherObserverMapElement.iPublisherControl = KService;

   683 	iPublisherObserverMap.Append(publisherObserverMapElement);

   684 

   685 	//Publish service nad update publish count

   686 	iPublishCount++;

   687 	iPublisherArray[publisherIndex].Publish( pnpBundle );

   688 

   689 	TBool SchedulerStart = EFalse;

   690 	_LIT(KSchedulerStart, "schedulerstart");

   691 	GetBoolFromConfig(aOperationType, KSchedulerStart, SchedulerStart);

   692 	if(SchedulerStart)

   693 		{

   694 		CActiveScheduler::Start();

   695 		}

   696 	_LIT(KInfoLogFile1, "PublishServiceL() End.... \n");

   697 	INFO_PRINTF1(KInfoLogFile1);

   698 	descriptionBuf.Close();

   699 	usnBuf.Close();

   700 	serviceTypeBuf.Close();

   701 	CleanupStack::PopAndDestroy( &pnpBundle );

   702 	}

   703 	

   704 /*

   705  * Get publisher mapping index for the given observer index

   706  */

   707 TInt CTestUPnPManager::GetPublisherIndex (TInt aObserverIndex)

   708 	{

   709 	_LIT(KInfoLogFile, "GetPublisherIndex.... \n");

   710 	INFO_PRINTF1(KInfoLogFile);

   711 	

   712 	TInt count = iPublisherObserverMap.Count();

   713 	for (TInt index(0); index < count ; index++ )

   714 		{

   715 		if (iPublisherObserverMap[index].iObserverIndex == aObserverIndex)

   716 			{

   717 			return iPublisherObserverMap[index].iPublisherIndex;

   718 			}

   719 		}

   720 	return KErrNotFound;

   721 	}

   722 

   723 /*

   724  * Gets publisher control i.e, Device/Service for the given observer index

   725  */

   726 TPublisherControl CTestUPnPManager::GetPublisherControl (TInt aObserverIndex)

   727 	{

   728 	_LIT(KInfoLogFile, "GetPublisherControl.... \n");

   729 	INFO_PRINTF1(KInfoLogFile);

   730 	

   731 	TInt count = iPublisherObserverMap.Count();

   732 	for (TInt index(0); index < count ; index++ )

   733 		{

   734 		if (iPublisherObserverMap[index].iObserverIndex == aObserverIndex)

   735 			{

   736 			return iPublisherObserverMap[index].iPublisherControl;

   737 			}

   738 		}

   739 	return KErrNoControl;

   740 	}

   741 

   742 /*

   743  * Gets publisher control i.e, Device/Service for the given observer index

   744  */

   745 TPublisherControl CTestUPnPManager::PublisherType (TInt aPublisherIndex)

   746 	{

   747 	_LIT(KInfoLogFile, "PublisherType.... \n");

   748 	INFO_PRINTF1(KInfoLogFile);

   749 	TInt count = iPublisherObserverMap.Count();

   750 	TPublisherControl publisherControl = KErrNoControl;

   751 	for (TInt index(0); index < count ; index++ )

   752 		{

   753 		if (iPublisherObserverMap[index].iPublisherIndex == aPublisherIndex)

   754 			{

   755 			switch (iPublisherObserverMap[index].iPublisherControl)

   756 				{

   757 				case KService:

   758 					{

   759 					publisherControl = KService;

   760 					break;

   761 					}

   762 				case KDevice:

   763 					{

   764 					publisherControl = KDevice;

   765 					break;

   766 					}

   767 				default :

   768 					{

   769 					publisherControl = KErrNoControl;

   770 					break;

   771 					}

   772 				}

   773 			}

   774 		}

   775 	_LIT(KInfoLogFile2, "PublisherType....End \n");

   776 	INFO_PRINTF1(KInfoLogFile2);

   777 	return publisherControl;

   778 	}

   779 

   780 TInt CTestUPnPManager::NotifyCount()

   781 	{

   782 	return iNotifyCount;

   783 	}

   784 

   785 TBool CTestUPnPManager::SendNotificationsL (CUPnPObserver* aObserver)

   786 	{

   787 	_LIT(KInfoLogFile, "SendNotificationsL.... \n");

   788 	INFO_PRINTF1(KInfoLogFile);

   789 	

   790     TInt observerIndex = iObserverArray.Find(aObserver);

   791     TInt publisherIndex = GetPublisherIndex(observerIndex);

   792     TPublisherControl publisherControl = GetPublisherControl(observerIndex);

   793 

   794     if(publisherControl != KService)

   795     	{

   796     	_LIT(KSendNotifyErr,"SEND NOTIFY NOT EXECUTED -- Can be Executed only ON Services...\n");

   797     	ERR_PRINTF1(KSendNotifyErr);

   798     	return EFalse;

   799     	}

   800     RPnPParameterBundle pnpBundle;

   801     pnpBundle.Open();   

   802     CleanupClosePushL( pnpBundle );

   803 	pnpBundle.SetPnPObserver((MPnPObserver*)this);

   804 

   805 	RParameterFamily pnpFamily = pnpBundle.CreateFamilyL(EUPnPServiceNotificationParamSet);

   806     CUPnPServiceNotificationParamSet* ServiceNotifyParamSet = CUPnPServiceNotificationParamSet::NewL (pnpFamily );

   807 

   808 	RBuf8 notificationDataBuf;

   809 	notificationDataBuf.CreateL(_L8("notification"));

   810 

   811 	ServiceNotifyParamSet->SetNotificationL (notificationDataBuf );

   812 	iNotifyCount++;

   813 	if(publisherIndex >= 0)

   814 		{

   815 		iPublisherArray[publisherIndex].SendNotify( pnpBundle );

   816 		_LIT(KSendNotify,"Info: SEND NOTIFY SUCCESSFUL...\n");

   817 		INFO_PRINTF1(KSendNotify);

   818 		}

   819 	else

   820 		{

   821 		_LIT(KSendNotifyFailed,"Err: SEND NOTIFY UNSUCCESSFUL...\n");

   822 		ERR_PRINTF1(KSendNotifyFailed);

   823 		}

   824 

   825 	CleanupStack::PopAndDestroy( &pnpBundle );

   826 	notificationDataBuf.Close();

   827 	_LIT(KInfoLogFile1, "SendNotificationsL End.... \n");

   828 	INFO_PRINTF1(KInfoLogFile1);

   829 	

   830 	return ETrue;

   831 	}

   832 

   833 /*

   834 	Extract service description available in a file, copy it to the buffer and append the same to service register paramset.

   835 	@param			aConfigSection - reference to a section name in ini file where required parameters that needs to be referred for this operation.

   836 					aServiceRegisterParamSet - Storage for the description buffer

   837 	@return			None.

   838  */

   839 

   840 void CTestUPnPManager::ExtractServiceDescriptionL (const TDesC& aConfigSection, CUPnPServiceRegisterParamSet& aServiceRegisterParamSet)

   841 	{

   842 	_LIT(KInfoLogFile, "ExtractServiceDescriptionL().... \n");

   843 	INFO_PRINTF1(KInfoLogFile);

   844 	

   845 	TPtrC descriptionPath;

   846 	_LIT(KDescriptionPath, "Description_Path");

   847 	GetStringFromConfig(aConfigSection, KDescriptionPath, descriptionPath);

   848 	

   849 	TPtrC description;

   850 	_LIT(KDescription, "description");

   851 	GetStringFromConfig(aConfigSection, KDescription, description);

   852 

   853 	if((descriptionPath == KNullDesC) && (description == KNullDesC)) 

   854 		{

   855 		_LIT8(KDefaultServiceDescription, "defaultservicedescription");

   856 		TBuf8<KMaxBufLength> descBuf;

   857 		descBuf.Copy(KDefaultServiceDescription);

   858 		aServiceRegisterParamSet.SetServiceDescriptionL (descBuf);

   859 		return;

   860 		}

   861 	else

   862 		{

   863 		RFs fs;

   864 		RFile file;

   865 		TInt err;

   866 		RBuf8 buf;

   867 		User::LeaveIfError(fs.Connect());

   868 		CleanupClosePushL(fs);

   869 		if(descriptionPath != KNullDesC)

   870 			{

   871 			err = file.Open(fs, descriptionPath, EFileShareReadersOnly);

   872 			

   873 			// For Hardware system path is c:, so descriptionPath value present in '.ini' is referring 'c:'

   874 			if ( err == KErrPathNotFound )

   875 				{				

   876 				RBuf fileName;

   877 				TDriveName aSystemDrive;

   878 				TDriveUnit driveunit(RFs::GetSystemDrive());

   879 				aSystemDrive.Zero();

   880 				aSystemDrive=driveunit.Name();				

   881 				fileName.CreateL ( descriptionPath.Length () );

   882 				fileName.Zero();

   883 				fileName.Append(aSystemDrive);

   884 				fileName.Append ( descriptionPath.Mid ( aSystemDrive.Length () ) );				

   885 				

   886 				err = file.Open(fs, fileName, EFileShareReadersOnly);

   887 				}

   888 			}

   889 		else 

   890 			{

   891 			err = file.Open(fs, description, EFileShareReadersOnly);

   892 			

   893 			// For Hardware system path is c:, so description value present in '.ini' is referring 'c:'

   894 			if ( err == KErrPathNotFound )

   895 				{

   896 				RBuf fileName;

   897 				TDriveName aSystemDrive;

   898 				TDriveUnit driveunit(RFs::GetSystemDrive());

   899 				aSystemDrive.Zero();

   900 				aSystemDrive=driveunit.Name();

   901 				fileName.CreateL ( description.Length () );

   902 				fileName.Zero();

   903 				fileName.Append(aSystemDrive);

   904 				fileName.Append ( description.Mid ( aSystemDrive.Length () ) );				

   905 				

   906 				err = file.Open(fs, fileName, EFileShareReadersOnly);

   907 				}

   908 			}

   909 

   910 		if (err != KErrNone)

   911 			{

   912 			User::LeaveIfError(err);

   913 			}

   914 		CleanupClosePushL(file);

   915 		TInt fileSize = 0;

   916 		file.Size(fileSize);

   917 		buf.Create(fileSize);

   918 		err = file.Read(buf, fileSize);

   919 		aServiceRegisterParamSet.SetServiceDescriptionL ( buf );

   920 		_LIT(KServiceDescription, "ServiceDescription is.... %S \n");

   921 		INFO_PRINTF2(KServiceDescription, &buf);

   922 		CleanupStack::PopAndDestroy(2);

   923 		buf.Close();

   924 		}

   925 	_LIT(KInfoLogFile1, "ExtractServiceDescriptionL() End.... \n");

   926 	INFO_PRINTF1(KInfoLogFile1);

   927 	}

   928 

   929 void CTestUPnPManager::ResolveScpdUrisL(TInt aIndex)

   930 	{

   931 	_LIT(KInfoLogFile, "ResolveScpdUrisL .... \n");

   932 	INFO_PRINTF1(KInfoLogFile);

   933 	if ( aIndex < 0 )

   934 		{

   935 		_LIT(KBadIndex, "BadIndex...ResolveScpdUrisL Cannot be executed \n");

   936 		ERR_PRINTF1(KBadIndex);

   937 		return;

   938 		}

   939 	const TInt KSlashLenghth = 1;

   940 	TUriParser8 uri;

   941 	uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);

   942 	TBuf8<KMaxUriSize> buf;

   943 	buf.Copy(uri.Extract(EUriScheme));

   944 

   945 	buf.Append(KColonSlashSlash);

   946 	buf.Append(uri.Extract(EUriHost));

   947 

   948 	buf.Append(KColon);

   949 	buf.Append(uri.Extract(EUriPort));

   950 

   951 	TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();

   952 	for (TInt scpdIndex(0); scpdIndex < count; scpdIndex++ )

   953 		{

   954 		RBuf8 scpdUri;

   955 		scpdUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl.Length());

   956 		scpdUri.Copy(buf);

   957 		 if (iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl.Find(KSlash)!=0)

   958 			 {

   959 			 scpdUri.Append(KSlash);

   960 			 }

   961 		 scpdUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl);

   962 		 AppendScpdUriL(scpdUri);

   963 		}

   964 	_LIT(KInfoLogFile1, "ResolveScpdUrisL End .... \n");

   965 	INFO_PRINTF1(KInfoLogFile1);

   966 	}

   967 

   968 void CTestUPnPManager::ResolveEventUrisL(TInt aIndex)

   969 	{

   970 	_LIT(KInfoLogFile, "ResolveEventUrisL.... \n");

   971 	INFO_PRINTF1(KInfoLogFile);

   972 	if ( aIndex < 0 )

   973 		{

   974 		_LIT(KBadIndex, "BadIndex...ResolveEventUrisL Cannot be executed \n");

   975 		ERR_PRINTF1(KBadIndex);

   976 		return;

   977 		}

   978 	const TInt KSlashLenghth = 1;

   979 	TUriParser8 uri;

   980 	uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);

   981 	TBuf8<KMaxUriSize> buf;

   982 	buf.Copy(uri.Extract(EUriScheme));

   983 

   984 	buf.Append(KColonSlashSlash);

   985 	buf.Append(uri.Extract(EUriHost));

   986 

   987 	buf.Append(KColon);

   988 	buf.Append(uri.Extract(EUriPort));

   989 

   990 	TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();

   991 	for (TInt eventIndex(0); eventIndex < count; eventIndex++ )

   992 		{

   993 		RBuf8 eventUri;

   994 		eventUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl.Length());

   995 		eventUri.Copy(buf);

   996 		 if (iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl.Find(KSlash)!=0)

   997 			 {

   998 			 eventUri.Append(KSlash);

   999 			 }

  1000 		 eventUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl);

  1001 		 AppendEventUriL(eventUri);

  1002 		}

  1003 	_LIT(KInfoLogFile1, "ResolveEventUrisL End.... \n"); 

  1004 	INFO_PRINTF1(KInfoLogFile1);

  1005 		

  1006 	}

  1007 

  1008 void CTestUPnPManager::ResolveControlUrisL(TInt aIndex)

  1009 	{

  1010 	_LIT(KInfoLogFile, "ResolveControlUrisL().... \n");

  1011 	INFO_PRINTF1(KInfoLogFile);

  1012 	if ( aIndex < 0 )

  1013 		{

  1014 		_LIT(KBadIndex, "BadIndex...ResolveControlUrisL Cannot be executed \n");

  1015 		ERR_PRINTF1(KBadIndex);

  1016 		return;

  1017 		}

  1018 	const TInt KSlashLenghth = 1;

  1019 	TUriParser8 uri;

  1020 	uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);

  1021 	TBuf8<KMaxUriSize> buf;

  1022 	buf.Copy(uri.Extract(EUriScheme));

  1023 

  1024 	buf.Append(KColonSlashSlash);

  1025 	buf.Append(uri.Extract(EUriHost));

  1026 

  1027 	buf.Append(KColon);

  1028 	buf.Append(uri.Extract(EUriPort));

  1029 

  1030 	TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();

  1031 	for (TInt ControlIndex(0); ControlIndex < count; ControlIndex++ )

  1032 		{

  1033 		RBuf8 controlUri;

  1034 		controlUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl.Length());

  1035 		controlUri.Copy(buf);

  1036 		 if (iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl.Find(KSlash)!=0)

  1037 			 {

  1038 			 controlUri.Append(KSlash);

  1039 			 }

  1040 		 controlUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl);

  1041 		 AppendControlUriL(controlUri);

  1042 		}

  1043 	_LIT(KInfoLogFile1, "ResolveControlUrisL() End.... \n");

  1044 	INFO_PRINTF1(KInfoLogFile1);

  1045 	}

  1046 

  1047 void CTestUPnPManager::ResolveIconUrlL ( TInt aBaseDescIdx, const TDesC8& aUrl )

  1048 	{

  1049 	_LIT(KInfoLogFile, "ResolveIconUrlL.... \n");

  1050 	INFO_PRINTF1(KInfoLogFile);

  1051 	

  1052 	const TInt KSlashLength = 1;

  1053 	TUriParser8 uri;

  1054 	uri.Parse(iDescriptionSuiteArray[aBaseDescIdx].iBaseUrl);

  1055 	TBuf8<KMaxUriSize> buf;

  1056 	buf.Copy(uri.Extract(EUriScheme));

  1057 	

  1058 	buf.Append(KColonSlashSlash);

  1059 	buf.Append(uri.Extract(EUriHost));

  1060 	

  1061 	buf.Append(KColon);

  1062 	buf.Append(uri.Extract(EUriPort));	

  1063 	

  1064 	RBuf8 iconUri;

  1065 	if ( aUrl[0] == TChar('/') )

  1066 		{

  1067 		iconUri.Create(buf.Length() + aUrl.Length());

  1068 		iconUri.Copy(buf);

  1069 		iconUri.Append (aUrl);

  1070 		}

  1071 	else

  1072 		{

  1073 		iconUri.Create(buf.Length() + KSlashLength + aUrl.Length());

  1074 		iconUri.Copy(buf);

  1075 		iconUri.Append(KSlash);

  1076 		iconUri.Append (aUrl);

  1077 		}

  1078 	

  1079 	iIconUriArray.Append (iconUri);

  1080 	

  1081 	_LIT(KInfoLogFile1, "ResolveIconUrlL End.... \n");

  1082 	INFO_PRINTF1(KInfoLogFile1);

  1083 	}

  1084 

  1085 /*

  1086 	Opens a handle to a RPnPServiceDiscovery object

  1087 	@param			None.

  1088 	@return			None.

  1089  */

  1090 void CTestUPnPManager::OpenDiscovererL()

  1091 	{

  1092 	_LIT(KInfoLogFile, "OpenDiscovererL().... \n");

  1093 	INFO_PRINTF1(KInfoLogFile);

  1094 	

  1095 	TBool cpStatus = EFalse;

  1096 	TInt openStatus = 0;

  1097 	_LIT(KCpStatus, "cpstatus");

  1098 	GetBoolFromConfig(GetCurrentSection(), KCpStatus, cpStatus);

  1099 	if(!cpStatus)

  1100 		{

  1101 		_LIT(KInfoDiscoverer, "Control Point should not be Created \n");

  1102 		INFO_PRINTF1(KInfoDiscoverer);

  1103 		return;

  1104 		}

  1105 	for(TInt i=0;i<3;i++)	

  1106 		{

  1107 		openStatus = iControlPoint.Open(KTierId);

  1108 		if(openStatus == KErrNone)

  1109 			{

  1110 			break;

  1111 			}

  1112 		}

  1113 	if(openStatus != KErrNone) 

  1114 		{

  1115 		_LIT(KOpenDiscovererFailed, "Control Point discovery open failed with error %d ");

  1116 		ERR_PRINTF2(KOpenDiscovererFailed, openStatus);

  1117 		SetTestStepError(openStatus);

  1118 		//SetTestStepResult(EFail); 

  1119 		}

  1120 	else

  1121 		{

  1122 		_LIT(KOpenDiscovererSuccess, "Control Point Discovery was successfully started with return value %d :");

  1123 		INFO_PRINTF2(KOpenDiscovererSuccess, openStatus);

  1124 		}

  1125 	}

  1126 

  1127 /*

  1128 	Opens a handle to a RPnPServicePublisher object and append the same to Publisher array

  1129 	@param			None.

  1130 	@return			TBool representing success or failure of the operation.

  1131  */

  1132 TInt CTestUPnPManager::OpenPublisherL()

  1133 	{

  1134 	_LIT(KInfoLogFile, "OpenPublisherL().... \n");

  1135 	INFO_PRINTF1(KInfoLogFile);