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

     2 // All rights reserved.

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

     4 // under the terms of "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 <e32const.h>

    17 #include <e32btrace.h>

    18 #include <f32file.h>

    19 #include "uloggerserver.h"

    20 #include "uloggersession.h"

    21 #include "uloggerclient.h"

    22 #include "uloggerplugin.h"

    23 #include "uloggershared.h"

    24 #include "uloggerdatatypes.h"

    25 #include "inputdata.h"

    26 #include "uloggercommands.h"

    27 

    28 #if defined(__LIGHTLOGGER_ENABLED)

    29 #include "lightlogger.h" 

    30 #endif

    31 

    32 

    33 namespace Ulogger {

    34 

    35 

    36 /*Default constructor*/

    37 CULoggerServer::CULoggerServer(TInt aPriority)

    38 : CServer2( aPriority )

    39 

    40 {

    41 	iIsBooting = ETrue;

    42 	iConfigManager = NULL;

    43 	iDataWatcher = NULL;

    44 	iOutputFramework = NULL;

    45 	iInputFramework = NULL;

    46 	iPluginAllocator = NULL;

    47 }

    48 

    49 

    50 /** Destructor will be called before re-starting

    51 */

    52 CULoggerServer::~CULoggerServer()

    53 {

    54 	delete iConfigManager;

    55 	delete iOutputFramework;

    56 	delete iInputFramework;

    57 	delete iPluginAllocator;

    58 	iPluginArray.ResetAndDestroy();

    59 	iPluginArray.Close();

    60     if(iDataWatcher)

    61     	{

    62     	iDataWatcher->Cancel();

    63     	delete iDataWatcher; 

    64     	}

    65 }

    66 

    67 /** Static Factory Construction 

    68 @return a pointer to the created object

    69 @leave KErrNoMemory if not enough memory available

    70 */

    71 CULoggerServer* CULoggerServer::NewLC(TInt aPriority)

    72 {

    73 	CULoggerServer* self = new (ELeave) CULoggerServer( aPriority );

    74 	CleanupStack::PushL( self );

    75 	self->ConstructL();

    76 

    77 	return self;

    78 }

    79 

    80 /**

    81 Create and install new Framework & Active Scheduler

    82 */

    83 void CULoggerServer::ConstructL()

    84 {

    85 	iRunAsService = EFalse; // Not used yet, to be used for run-as-service functionality

    86 	iBufferSize = KMaxBufferSize;

    87 	iBtraceOpen = EFalse;

    88 	iDataNotification = 0;

    89 

    90 	StartL( KServerName );	

    91 	iConfigManager = CConfigFileManager::NewL();

    92 

    93 }

    94 

    95 

    96 /**

    97 Create a new server session. 

    98 @note Called by kernel after client's thread use any of the macros for the first time.

    99 */

   100 CSession2* CULoggerServer::NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const

   101 {

   102  	TVersion v(KULoggerSrvMajorVersionNumber,KULoggerSrvMinorVersionNumber,KULoggerSrvBuildVersionNumber);

   103     if (!User::QueryVersionSupported(v,aVersion))

   104          User::Leave(KErrNotSupported);

   105 

   106 	RThread client;

   107 	aMessage.Client(client);

   108 	return CULoggerSession::NewL( client, *const_cast<CULoggerServer*>(this) );

   109 }

   110 

   111 

   112 /*Increment session counter*/

   113 void CULoggerServer::IncrementSessions()

   114 {	

   115 	++iSessionCounter;

   116 }

   117 

   118 /*Decrement session counter*/

   119 void CULoggerServer::DecrementSessions()

   120 	{

   121 	if(--iSessionCounter <= 0)

   122 		{

   123 		if (!iBtraceOpen)

   124 			ShutDownServer();

   125 

   126 //

   127 // // Replace above if-statement with following to implement run-as-service functionality

   128 //

   129 //		if((!iBtraceOpen) && (!iRunAsService))

   130 //			ShutDownServer();

   131 //

   132 

   133 		}

   134 	}

   135 

   136 /*!

   137 Shuts down the server

   138 */

   139 void CULoggerServer::ShutDownServer()

   140 {

   141 	CActiveScheduler::Stop();

   142 }//</ShutDownServer>

   143 

   144 

   145 

   146 

   147 /*!

   148 Return the error value

   149 */

   150 TInt CULoggerServer::RunError(TInt aError)

   151 {

   152 	Message().Complete(aError);

   153 	ReStart();

   154 

   155 	return KErrNone;

   156 }

   157 

   158 

   159 

   160 

   161 void CULoggerServer::PanicServer(TULoggerSrvPanics aPanic)

   162 {

   163 	User::Panic(KServerName, aPanic);

   164 }//</PanicServer>

   165 

   166 

   167 

   168 /*!

   169 */

   170 void CULoggerServer::PanicClient(const RMessage2& aMessage, TULoggerSrvPanics aPanic)

   171 {

   172 	aMessage.Panic( KServerName, aPanic );

   173 }//</PanicClient>

   174 

   175 

   176 

   177 

   178 ////////////////////////////////////////////////////////////////////////////////////////////////////////////

   179 /**

   180 ServerL

   181 @Installs the active scheduler

   182 @Opens the semaphore

   183 */

   184 TInt CULoggerServer::StartServerL()

   185 {

   186 	#if defined(__LIGHTLOGGER_ENABLED)

   187 	__CREATE_LOG(EFalse)

   188 	__HIRES_RESOLUTION

   189 	#endif	

   190 	

   191     CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler();

   192     CleanupStack::PushL(activeScheduler) ;

   193     CActiveScheduler::Install(activeScheduler);

   194     CULoggerServer* server = NULL;

   195 	TInt servererr = KErrNone;

   196 	TRAP(servererr,

   197 		{

   198 		server = CULoggerServer::NewLC((TProcessPriority)EPriorityHigh);

   199 		CleanupStack::Pop();

   200 		});

   201 	

   202 	if(servererr==KErrNone||servererr==KErrNotFound )

   203 		{

   204 		RProcess::Rendezvous(KErrNone);

   205 		servererr=KErrNone;

   206 		CActiveScheduler::Start();

   207 		}

   208 	else

   209 		{

   210 		RProcess::Rendezvous(servererr);		

   211 		}

   212 	delete server;

   213    	CleanupStack::PopAndDestroy();

   214 	return servererr;

   215 	

   216 }//</StartingFunctionL>

   217 

   218 

   219 /**

   220 Function to to start the server 

   221 This should leave with KErrNone 

   222 */

   223 TInt CULoggerServer::StartServer()

   224 {

   225 	CTrapCleanup* cleanupStack = CTrapCleanup::New();

   226 	if (!cleanupStack)

   227 	{

   228         	return KErrNoMemory;

   229 	}

   230 	TInt err;

   231     TRAP(err, StartServerL());

   232    

   233     delete cleanupStack;

   234     cleanupStack = NULL;

   235 

   236     return err;

   237 }//</StartingFunction>

   238 

   239 

   240 /**

   241 Function to set the active output media 

   242 This should leave with KErrNotFound if given plugin is not the correct one

   243 or the file doesn't exists in the user and public path

   244 */

   245 

   246 TInt CULoggerServer::SetActiveOutputPlugin(const TDesC8 &aPluginname)

   247 {

   248 	RArray<TPtrC8> activePluginsArray;

   249 	TInt error= KErrNone;

   250 

   251 	error = GetInstalledOutputPlugins(activePluginsArray);

   252 	if(error==KErrNone)

   253 		{

   254 		for(TInt i=0;i<activePluginsArray.Count();i++)

   255 			{

   256 			if(aPluginname.Compare(activePluginsArray[i])==0)

   257 				{

   258 				error = iConfigManager->SetActiveOutputPlugin(aPluginname);

   259 				break;

   260 				}	

   261 			else 

   262 				error = KErrNotFound;

   263 			}

   264 		}

   265 	if(error == KErrAlreadyExists)

   266 		{

   267 		error=KErrNone;

   268 		}

   269 	return error;

   270 }

   271 

   272 

   273 TInt CULoggerServer::SetActiveInputPlugin(const TDesC8 &aPluginname)

   274 	{

   275 	RArray<TPtrC8> activePluginsArray;

   276 	TInt ret= KErrNone;

   277 	//check configuration file in user path (\\ulogger\\uloggerconfig.ini)	

   278 

   279 	ret = GetInstalledInputPlugins(activePluginsArray);

   280 	if(ret==KErrNone)

   281 		{

   282 		ret = KErrNotFound;

   283 		for(TInt i=0;i<activePluginsArray.Count();i++)

   284 			{

   285 			if(aPluginname.Compare(activePluginsArray[i])==0)

   286 				{

   287 				ret = iConfigManager->SetActiveInputPlugin(aPluginname);

   288 				break;	

   289 				}

   290 			}

   291 		}

   292 	return ret;

   293 	}

   294 

   295 

   296 /**

   297 Function to set the plugin settings

   298 This should leave with KErrNotFound if cannot file doesn't exist

   299 */

   300 TInt CULoggerServer::SetPluginSettings(const TDesC8 &aPluginname, RArray<TPtrC8>& aListBuffer)

   301 {	

   302 	TInt i = 0;

   303 	TInt ret=KErrNone;

   304 

   305 	//if plug-in doesn't exists

   306 	TPtrC8 pluginName(aPluginname);

   307 	if(!CheckPluginExists(pluginName, EOutputPluginFilter) && !CheckPluginExists(pluginName, EInputPluginFilter))

   308 		return KErrNotFound;

   309 	

   310 	while(i<aListBuffer.Count())

   311 		{

   312 		TPtrC8 key(aListBuffer[i]);

   313 		TPtrC8 val(aListBuffer[++i]);

   314 		ret = iConfigManager->SetPluginSetting(aPluginname, key, val);

   315 		if(ret!=KErrNone)

   316 			break;

   317 		i++;		

   318 		}					

   319 	return ret;

   320 }

   321 

   322 

   323 

   324 

   325 /**

   326 Function to get the plugin settings

   327 This should leave with KErrNotFound if cannot find one

   328 */

   329 TInt CULoggerServer::GetOptionsSettingsL(const TDesC8 &aMediaName, RArray<TPtrC8>& aListBuffer)

   330 {

   331 	//if plug-in doesn't exists

   332 	TPtrC8 pluginName(aMediaName);

   333 	if(!CheckPluginExists(pluginName, EOutputPluginFilter) && !CheckPluginExists(pluginName, EInputPluginFilter))

   334 		return KErrNotFound;

   335 	else

   336 		{

   337 		TInt ret = GetValues(aMediaName,aListBuffer);

   338 		if(ret == KErrNotFound) //this error indicate that there is no section in config file, plug-in exists

   339 			ret = KErrNone;

   340 		return ret;

   341 		}

   342 }

   343 

   344 

   345 

   346 /**

   347 Function to get values from the configuration file (i.e. for filters,plugin settings)

   348 This should leave with KErrNotFound if it cannot find the configuration file

   349 */

   350 TInt CULoggerServer::GetValues(const TDesC8 &aSectionName, RArray<TPtrC8>& aListBuffer)

   351 {	

   352 	TPtrC8 key;

   353 	TPtrC8 val;

   354 	TInt err = KErrNotFound;	

   355 

   356 	Ulogger::CConfigSettingsIter* iter = Ulogger::CConfigSettingsIter::NewL();

   357 	CleanupStack::PushL(iter);

   358 	

   359 	//check User configuration file if exists

   360 	//check values for given section in the configuration file 

   361 	//if value exists copy it to array 

   362 	err = iConfigManager->GetSectionValues(aSectionName,*iter);

   363 	if(err == KErrNone)

   364 		{

   365 		TBool found =EFalse;

   366 		while(iter->Next(key,val))

   367 			{

   368 			aListBuffer.AppendL(key);

   369 			aListBuffer.AppendL(val);

   370 			found = ETrue;

   371 			}

   372 		if(!found)

   373 			err = KErrNotFound;

   374 		}

   375 	CleanupStack::PopAndDestroy(); // list

   376 	return err;

   377 	

   378 }

   379 

   380 

   381 /**

   382 Sets the Active Filter in the configuration file (primary and secondary filters)

   383 @aCategory filters to be set

   384 @aDupCategory duplicate filters which are not set

   385 @aFilter value that describes primary or secondary filter

   386 @return KErrNone, if successful, otherwise one of the other system-wide

   387         error codes.

   388 */

   389 TInt CULoggerServer::SetActiveFilter(RArray<TUint32> aCategory, TInt aFilterType)

   390 {

   391 	TInt error = KErrNone;

   392 	if(aFilterType == 1)

   393 		{

   394 		if(aCategory.Count()==0 || aCategory.Count()>KMaxPrimaryFiltersLimit)

   395 			error = KErrArgument;

   396 		else

   397 			{

   398 			error = iConfigManager->SetActiveFilter(aCategory,KPrimaryFilterSection);

   399 			if(error == KErrAlreadyExists)

   400 				error = KErrNone;

   401 			}

   402 		}

   403 	if(aFilterType == 2)

   404 		{

   405 		//we don't want to set more secondary filters than KMaxSecondaryFiltersLimit

   406 		RArray<TUint32> tmpArray;

   407 		CleanupClosePushL(tmpArray);

   408 		error = GetActiveFilters(tmpArray, ESecondaryFilter);

   409 		if(!error || error == KErrNotFound)

   410 			{

   411 			error = KErrNone; //in case it was KErrNotFound as it doesn't matter we didn't have any set already

   412 			if(aCategory.Count()==0 ||tmpArray.Count() > KMaxSecondaryFiltersLimit ||

   413 					(tmpArray.Count()+ aCategory.Count()) > KMaxSecondaryFiltersLimit)

   414 				error = KErrArgument;

   415 				

   416 			}

   417 		CleanupStack::PopAndDestroy(); //tmpArray

   418 		if(!error)

   419 			error = iConfigManager->SetActiveFilter(aCategory,KSecondaryFilterSection);

   420 		}

   421 	return error;

   422 }

   423 	

   424 

   425 /**

   426 Function to remove the Filter from config file

   427 @aFilter  Filter to be removed

   428 @aValue primary or secondary filter to be removed

   429 This should leave with KErrNotFound if cannot find one or any system wide error codes

   430 */

   431 TInt CULoggerServer::RemoveActiveFilter(RArray<TUint32>& aValue, const TInt aFilter)

   432 {

   433 	TInt ret = KErrNone;

   434 	//remove filter (primary or secondary) from BTrace current configuration

   435 	if(aFilter == EPrimaryFilter && (aValue.Count()==0 || aValue.Count()>KMaxPrimaryFiltersLimit))

   436 		return KErrArgument;

   437 	else if(aFilter == ESecondaryFilter && (aValue.Count()==0 || aValue.Count()>KMaxSecondaryFiltersLimit))

   438 		return KErrArgument;

   439 		

   440 	ret = iConfigManager->RemoveActiveFilter(aValue,aFilter);

   441 	if(ret == KErrNotFound) //remove operation should succeed in this situation

   442 		ret = KErrNone;

   443 		

   444 	return ret;

   445 }

   446 

   447 

   448 /**

   449 Function to set Trace settings to the configuration file

   450 @aValue  value to be set

   451 @aSetting setting to which value to be set

   452 This should leave with KErrNotFound if cannot find one or any system wide error codes

   453 */

   454 TInt CULoggerServer::SetTraceSettings(const TDesC8&  aValue, const TDesC8& aSetting)

   455 	{

   456 	TInt r = iConfigManager->SetTraceSettings(aValue, aSetting);

   457 	return r;

   458 

   459 	}

   460 

   461 /**

   462 Function to remove plugin settings from the configuration file

   463 @aPluginName  Plugin name whose settings has to be removed

   464 @return will return KErrNone or else leave with KErrNotFound  

   465 	or any system wide error codes 

   466 */

   467 

   468 TInt CULoggerServer::RemovePluginSettingsL(const TDesC8 &aPluginName)

   469 	{

   470 	if(aPluginName.Length() == 0)

   471 		return KErrArgument;

   472 	

   473 	TInt ret = KErrNone;

   474 	RArray<TPtrC8> settings;

   475 	ret = GetOptionsSettingsL(aPluginName, settings);

   476 	if(ret != KErrNone || settings.Count()==0)

   477 		ret = KErrNotFound;

   478 	settings.Close();

   479 		

   480 	if(ret == KErrNone)

   481 		return iConfigManager->RemovePluginSettings(aPluginName);

   482 	else

   483 		return ret;

   484 	}

   485 

   486 /**

   487 Resize the BTrace buffer size

   488 

   489 @aSize The size to be set for the BTrace buffer.

   490 @return KErrNone, if successful, otherwise one of the other system-wide

   491         error codes.

   492 */

   493 TInt CULoggerServer::SetBufferSize(TInt aSize)

   494 	{

   495 	if(aSize > KMaxBufferSize || aSize < 1)

   496 		return KErrArgument;

   497 

   498 	

   499 	//get dns to check

   500 	GetBufandDataNotifyValuesL(KDataNotification,iDataNotification);

   501 	if(aSize < iDataNotification)

   502 		return KErrGeneral;

   503 	

   504 	iBufferSize = aSize;

   505 	HBufC8* Size = HBufC8::NewLC(32);

   506 	Size->Des().Num(iBufferSize);

   507 	CleanupStack::Pop(1);

   508 	TPtr8 ptr(Size->Des());

   509 	TInt r = iConfigManager->SetTraceSettings((const TDesC8&)ptr, KBuffer);

   510 	return r;

   511 	}

   512 

   513 

   514 /**

   515 Change the mode of the BTrace Buffer

   516 

   517 @aValue The mode to be set for the BTrace buffer.

   518 @return KErrNone, if successful, otherwise one of the other system-wide

   519         error codes.

   520 */

   521 TInt CULoggerServer::SetBufferMode(const TDesC8& aValue)

   522 	{

   523 	

   524 	TInt r = SetTraceSettings(aValue, KBufferMode);

   525 	return r;

   526 	}

   527 

   528 /**

   529 Resize the Data Notification size

   530 

   531 @aSize The size to be set for the Data Notification size.

   532 @return KErrNone, if successful, otherwise one of the other system-wide

   533         error codes.

   534 */

   535 TInt CULoggerServer::SetDataNotificationSize(TInt aSize)

   536 	{

   537 	if(aSize > KMaxDnsSize || aSize < 0)

   538 		return KErrArgument;

   539 	TInt size, r;

   540 	TRAP_IGNORE((r=GetBufandDataNotifyValuesL(KBuffer,size)));

   541 	if(aSize > size)

   542 		return KErrGeneral;

   543 	

   544 	iDataNotification = aSize;

   545 	HBufC8* Size = HBufC8::NewLC(32);

   546 	Size->Des().Num(aSize);

   547 	TPtr8 ptr(Size->Des());

   548 	r = SetTraceSettings((const TDesC8&)ptr, KDataNotification);

   549 	CleanupStack::PopAndDestroy();

   550 	return r;

   551 	}

   552 	

   553 /**

   554 Function to retrieve the Trace Section Values

   555 This should leave with KErrNotFound if cannot find one

   556 as this should be treated as a corrupt config file

   557 */

   558 void CULoggerServer::GetOptionsSettingsL(RArray<TPtrC8>& aListBuffer,const TDesC8& aSetting)

   559 {

   560 	TPtrC8 key;

   561 	TPtrC8 val;	

   562 	TInt err=0;

   563 	

   564 	Ulogger::CConfigSettingsIter* iter = Ulogger::CConfigSettingsIter::NewL();

   565 	CleanupStack::PushL(iter);

   566 	err=iConfigManager->GetPluginSettings(*iter);

   567 	

   568 	if(err==KErrNone)

   569 		{

   570 		while(iter->Next(key,val))

   571 			{

   572 			if(key.Compare(aSetting)==0)

   573 				{

   574 				aListBuffer.AppendL(key);

   575 				aListBuffer.AppendL(val);					

   576 				}

   577 			}

   578 		}

   579 	CleanupStack::PopAndDestroy(); // list

   580 }

   581 

   582 /**

   583 Function to retrieve the active primary filters

   584 This should leave with KErrNotFound if cannot find one

   585 as this should be treated as a corrupt config file

   586 */

   587 TInt CULoggerServer::GetBufandDataNotifyValuesL(const TDesC8& aSetting,TInt& value)

   588 	{

   589 	TInt err = KErrNotFound;

   590 	RArray<TPtrC8> traceValues;

   591 	TFileName filepath;

   592 	

   593 	GetOptionsSettingsL(traceValues,aSetting);

   594 		

   595 	value =-1;

   596 	//if values exists for the given trace settings	

   597 	if(traceValues.Count()>1)

   598 		{// get values for buffer mode

   599 		if(aSetting.Compare(KBufferMode)==0)	

   600 			{

   601 			err=KErrNone;

   602 			if(traceValues[1].Compare(KCircular) == 0)

   603 				value = ECircularBuffer;

   604 			else if(traceValues[1].Compare(KStraight) == 0)

   605 				value = EStraightBuffer;

   606 			else

   607 				err=KErrNotFound;

   608 			}

   609 		else

   610 			{// get values for data notification and buffer size

   611 			TLex8 lex_val(traceValues[1]);	

   612 			err = lex_val.Val(value);

   613 			}

   614 		}

   615 	return err;

   616 	}

   617 	

   618 

   619 

   620 /**

   621 Set the enable/disable secondary filters

   622 

   623 @aSize The size to be set for the BTrace buffer.

   624 @return KErrNone, if successful, otherwise one of the other system-wide

   625         error codes.

   626 */

   627 TInt CULoggerServer::SetSecondaryFiltering(const TDesC8& aEnabled)

   628 	{

   629 	TInt error = iConfigManager->SetTraceSettings(aEnabled, KSecondaryGlobalFilter);

   630 	if(error == KErrAlreadyExists)

   631 		error = KErrNone;

   632 	return error;

   633 

   634 	}	

   635 

   636 

   637 /**

   638 Function to retrieve the active primary and secondary filters

   639 This should leave with KErrNotFound if cannot find one or any system wide error codes

   640 */

   641 TInt CULoggerServer::GetActiveFilters(RArray<TUint32>& aListBuffer,TInt aFilterType)

   642 	{

   643 	TInt ret = KErrNotFound;

   644 	RArray<TPtrC8> aValues;

   645 	if(aFilterType == 1)

   646 		{

   647 		ret = GetValues(KPrimaryFilterSection,aValues);

   648 		if(ret==KErrNone)	

   649 			{

   650 			TInt i =0;

   651 			TPtrC8 val;	

   652 			TUint8 int_val;

   653 			while(i<aValues.Count())

   654 				{

   655 				TLex8 lex_val(aValues[++i]);	

   656 				ret = lex_val.Val(int_val,EDecimal);	

   657 				if(ret==KErrNone)

   658 					aListBuffer.Append(int_val);

   659 				else

   660 					return KErrCorrupt;

   661 				i++;		

   662 				}					

   663 			}

   664 		}

   665 	else if(aFilterType == 2)

   666 		{

   667 		ret = GetValues(KSecondaryFilterSection,aValues);

   668 		if(ret==KErrNone)	

   669 			{

   670 			TInt i =0;

   671 			TPtrC8 val;	

   672 			TUint int_val;

   673 			while(i<aValues.Count())

   674 				{

   675 				TLex8 lex_val(aValues[++i]);	

   676 				ret = lex_val.Val(int_val,EDecimal);	

   677 				if(ret==KErrNone)

   678 					aListBuffer.Append(int_val);

   679 				else

   680 					return KErrCorrupt;

   681 				i++;		

   682 				}					

   683 			}

   684 		else

   685 			{

   686 			if(ret==KErrNotFound)//i.e. if there are no values in the array --> change to if(filters.Count = 0)?

   687 				ret=KErrNone;

   688 			}

   689 		}

   690 	return ret;

   691 	}

   692 

   693 /**

   694 Function to retrieve the active secondary global filter

   695 This should leave with KErrNotFound if cannot find one

   696 */

   697 

   698 TInt CULoggerServer::GetSecondaryFiltering(TBool& aEnabled)

   699 {

   700 	RArray<TPtrC8> configSettings;			

   701 	TRAPD(error, GetOptionsSettingsL(configSettings,KSecondaryGlobalFilter));

   702 	if(configSettings[1]==KEnable) //First element contains KSecondaryGlobalFilter, second the value

   703 		aEnabled = ETrue;

   704 	if(configSettings[1]==KDisable)

   705 		aEnabled = EFalse;

   706 	return error; 

   707 }

   708 

   709 /**

   710 Function to retrieve the plugin names from the ECOM framework

   711 This should leave with KErrNotFound if cannot find one

   712 */

   713 TInt CULoggerServer::GetInstalledOutputPlugins(RArray<TPtrC8>& aListBuffer)

   714 	{

   715 	// Read info about all implementations into infoArray

   716 	// Note that a special cleanup function is required to reset and destroy

   717 	// all items in the array, and then close it.

   718 	if(iPluginArray.Count()>0)

   719 	{

   720      iPluginArray.ResetAndDestroy();

   721      iPluginArray.Close();

   722 	}

   723 	

   724 	TRAPD(error,CPluginAllocator::ListAllImplementationsL(iPluginArray));

   725 

   726 	if(iPluginArray.Count()>0)

   727 	{

   728 		for (TInt i=0; i< iPluginArray.Count(); i++)

   729 			{

   730 			TRAP(error,aListBuffer.AppendL(iPluginArray[i]->DataType()));

   731 			}

   732 	

   733 		//filter plugins and to use only output plugins

   734 		FilterPlugins(EOutputPluginFilter, aListBuffer);

   735 	}

   736 	

   737 	return error;

   738 	}

   739 	

   740 

   741 

   742 TInt CULoggerServer::GetInstalledInputPlugins(RArray<TPtrC8>& aListBuffer)

   743 	{

   744 	#if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)

   745 	__MARK_METHOD("CULoggerServer::GetInstalledControlPlugins")

   746 	#endif

   747 	

   748 	if(iPluginArray.Count()>0)

   749 		{

   750 	     iPluginArray.ResetAndDestroy();

   751 	     iPluginArray.Close();

   752 		}

   753 	// Read info about all implementations into infoArray

   754 	// Note that a special cleanup function is required to reset and destroy

   755 	// all items in the array, and then close it.

   756 	CPluginAllocator::ListAllImplementationsL(iPluginArray);

   757 		

   758 	if(iPluginArray.Count() > 0)

   759 		{	

   760 		for (TInt i=0; i< iPluginArray.Count(); i++)

   761 			aListBuffer.AppendL(iPluginArray[i]->DataType());

   762 		

   763 		//filter plugins and to use only output plugins

   764 		FilterPlugins(EInputPluginFilter, aListBuffer);

   765 		}

   766 	return KErrNone;

   767 	}

   768 

   769 

   770 /**

   771 Function to retrieve the Active plugin name 

   772 This should leave with KErrNotFound if cannot find one or any system wide error codes

   773 */

   774 TInt CULoggerServer::GetActiveOutputPlugin(RArray<TPtrC8>& aListBuffer)

   775 	{

   776 	TInt errCode = GetValues(KActiveSection,aListBuffer);

   777 	//plugins are received as, e.g. '1 uloggerfileplugin' (.ini file syntax)

   778 	//we have to remove number from array

   779 	for(TInt i=0; i<aListBuffer.Count(); ++i)

   780 		{

   781 		TInt v;

   782 		TLex8 lex(aListBuffer[i]);

   783 		if(lex.Val(v) == KErrNone)

   784 			{

   785 			aListBuffer.Remove(i);

   786 			i=-1; //start from begin, i will be incremented in loop

   787 			}

   788 		}

   789 	return errCode;

   790 	}

   791 

   792 

   793 /**

   794 Function to Deactivate or remove active output plugin 

   795 This should leave with KErrNotFound if cannot find one or any system wide error codes

   796 */

   797 

   798 TInt CULoggerServer::DeActivateOutputPlugin(const TDesC8 &aPluginname)

   799 {	

   800 	if(iBtraceOpen != EFalse)

   801 		{

   802 		Stop();

   803 		iBtraceOpen = EFalse;

   804 		}

   805 	

   806 	TInt ret = iConfigManager->DeActivateOutputPlugin(aPluginname);

   807 	return ret;

   808 }

   809 

   810 /**

   811 Function to retrieve the Active control plugin name 

   812 This should leave with KErrNotFound if cannot find one or any system wide error codes

   813 */

   814 TInt CULoggerServer::GetActiveInputPlugin(RArray<TPtrC8>& aListBuffer)

   815 	{

   816 	return GetValues(KActiveControlSection,aListBuffer);

   817 	}

   818 

   819 /**

   820 Function to Deactivate active control plugin 

   821 This should leave with KErrNotFound if cannot find one or any system wide error codes

   822 */

   823 TInt CULoggerServer::DeActivateInputPlugin(const TDesC8& aPluginname)

   824 	{

   825 	return iConfigManager->DeActivateInputPlugin(aPluginname);

   826 	}

   827 

   828 /**

   829 Function to run ULogger server as service, i.e. to keep it constantly running

   830 (but not necessarily logging) in the background, or to stop it being run as a

   831 service (if EFalse is passed).

   832 

   833 @param aRunAsService ETrue to start, EFalse to stop running as service

   834 */

   835 void CULoggerServer::RunAsService(TBool /*aRunAsService*/)

   836 	{

   837 //

   838 // // Uncomment following to implement run-as-service functionality

   839 //

   840 //	iRunAsService = aRunAsService;

   841 //

   842 //	if (!aRunAsService)

   843 //		{

   844 //		//make sure server is stopped if there are no sessions

   845 //		IncrementSessions();

   846 //		DecrementSessions();

   847 //		}

   848 	}

   849 

   850 /**

   851 Function to cd.. ulogger server

   852 This should leave with KErrNotFound if cannot find one or any system wide error codes

   853 */

   854 TInt CULoggerServer::Start()

   855 	{

   856 	#if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)

   857 	__MARK_METHOD("CULoggerServer::Start")

   858 	#endif

   859 

   860 	TRAPD(error, InitializeFrameworksL());

   861 	

   862 	//check errors

   863 	if(error != KErrNone)

   864 		return error;

   865 	if(!iOutputFramework)

   866 		return KErrNotReady;

   867 	if(iBtraceOpen)

   868 		return KErrInUse;

   869 

   870 	TPtrC8 key;

   871 	TPtrC8 val;

   872 	TInt buffermode=0;

   873 	RArray<TPtrC8> settings;

   874 	RArray<TUint32> activefilters;

   875 	//checking if there is at least one active channel

   876 	error = GetActiveOutputPlugin(settings);

   877 	if(error != KErrNone)

   878 		return error;

   879 	if(settings.Count()==0)

   880 		{

   881 		return KErrNotFound; //active output plug-in not found

   882 		}

   883 

   884 	if(iBtraceOpen == EFalse)

   885 		{

   886 		if(iIsBooting)

   887 			error = TraceSettingsOnBoot();

   888 		else

   889 			error = iTrace.Open();

   890 

   891 		if(error == KErrNone)

   892 			{

   893 			//----Reset the notification size

   894 			TRAP_IGNORE(error=GetBufandDataNotifyValuesL(KDataNotification,iDataNotification));

   895 			if(error!=KErrNone)

   896 				return error;

   897 			TRAP_IGNORE(error=GetBufandDataNotifyValuesL(KBuffer,iBufferSize));

   898 			if(error!=KErrNone)

   899 				return error;

   900 

   901 			//----Reset BTrace filters

   902 			ResetBtracePrimaryFilters(iTrace);

   903 

   904 			//----Resize the trace buffer

   905 			error = iTrace.ResizeBuffer(iBufferSize*1024);

   906 			if(error == KErrNoMemory)

   907 			{

   908 				error = iTrace.ResizeBuffer(KMinBufferMTPLE*1024);

   909 			}

   910 			if(error != KErrNone)

   911 				return error;

   912 			//----Reset the buffer mode

   913 			TRAP_IGNORE(GetBufandDataNotifyValuesL(KBufferMode,buffermode));

   914 			if(buffermode==ECircularBuffer)

   915 			{

   916 				iTrace.SetMode(RBTrace::EFreeRunning|RBTrace::EEnable);	

   917 			}

   918 			else

   919 			{

   920 				iTrace.SetMode(RBTrace::EEnable);

   921 			}

   922 		

   923 			//----Enable/disable primary filter

   924 			error = GetActiveFilters(activefilters,EPrimaryFilter);

   925 			if(error != KErrNone)

   926 				return error;

   927 			for(TInt i=0; i<activefilters.Count(); ++i)

   928 				{

   929 				TUint filter;

   930 				filter= (TUint8)activefilters[i];

   931 				iTrace.SetFilter(filter,ETrue);

   932 				}

   933 

   934 			//----Enable/disable secondary filter

   935 			settings.Reset();

   936 			TBool enabled = EFalse;

   937 			error = GetSecondaryFiltering(enabled);

   938 			if(!error)

   939 				{

   940 				if (enabled)//enable secondary filter, only traces with certain value will pass

   941 					{

   942 					iTrace.SetFilter2(0);

   943 

   944 					//enable secondary filters chosen by user

   945 					activefilters.Reset();

   946 					if((error = GetActiveFilters(activefilters,ESecondaryFilter)) == KErrNone)

   947 						for(TInt i=0; i<activefilters.Count(); ++i)

   948 							iTrace.SetFilter2(activefilters[i], ETrue);

   949 					else

   950 						{

   951 						if(error == KErrNotFound)

   952 							{

   953 							error = KErrNone;

   954 							}

   955 						else

   956 							return error;

   957 						}

   958 					}

   959 				else//disable secondary filter, all traces will pass

   960 					{

   961 					iTrace.SetFilter2(1);

   962 					}				

   963 				}

   964 			

   965 			//set flag to idicate that btrace is open

   966 			iBtraceOpen = ETrue;

   967 

   968 			//start input and output frameworks

   969 			iInputFramework->StartReading(); //start waiting for remote commands

   970 			AsynchDataRequest();

   971 			}

   972 		}

   973 	else

   974 		error = KErrInUse;

   975 

   976 	return error;

   977 	}

   978 

   979 /**

   980 Close the BTrace handle to the buffer

   981 @return none

   982 */

   983 TInt CULoggerServer::Stop()

   984 {

   985 	#if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)

   986 	__MARK_METHOD("CULoggerServer::Stop")

   987 	#endif

   988 	

   989 	if(iBtraceOpen)

   990 	{	

   991 		TInt errCode = KErrNone;

   992 		TRAP(errCode, ReadBufferL());	//flush the BTrace buffer

   993 		

   994 		ResetBtracePrimaryFilters(iTrace);//reset BTrace filters

   995 		

   996 		iTrace.CancelRequestData();	

   997 		iTrace.Empty();

   998 		iTrace.Close();

   999 		iBtraceOpen = EFalse;

  1000 		iDataWatcher->Cancel();

  1001 		

  1002 		//stop waiting/reading for remote commands

  1003 		iInputFramework->StopReading();

  1004 		iOutputFramework->ReleaseOutputResources();

  1005 		return KErrNone;

  1006 		}

  1007 	else

  1008 		{

  1009 		return KErrNotReady;	

  1010 		}

  1011 		

  1012 }

  1013 

  1014 /**

  1015 Gets the Trace settings on boot

  1016 @return none

  1017 */

  1018 TInt CULoggerServer::TraceSettingsOnBoot()

  1019 {

  1020 

  1021 	TInt trace = FALSE;

  1022 	

  1023 	RArray<TUint32> category;

  1024 	TInt error = iTrace.Open();

  1025 	if(error != KErrNone)

  1026 		return error;

  1027 	

  1028 	TInt bufferSize = iTrace.BufferSize(); //To get the buffer size set at boot	

  1029 	if(bufferSize <= 0 && bufferSize > KMaxBufferSize)

  1030 		SetBufferSize(KMaxBufferSize); //Update config

  1031 	else

  1032 		SetBufferSize(bufferSize); //Update config

  1033 	for(TUint i=0; i<KMaxPrimaryFiltersLimit; i++)

  1034 	{

  1035 		trace = iTrace.Filter(i);

  1036 		if(trace == 1)         

  1037 			category.AppendL((TUint32)i);				

  1038 	}

  1039 	error = iConfigManager->SetActiveFilter(category,KPrimaryFilterSection);

  1040 	category.Close();

  1041 	iIsBooting=0;

  1042 	return error;

  1043 }

  1044 

  1045 

  1046 

  1047 /**

  1048 Reads the BTrace buffer and transfers the collected logs to

  1049 the ACTIVE channel

  1050 */

  1051 void CULoggerServer::ReadBufferL()

  1052     {

  1053     if(iBtraceOpen)

  1054     	{   	

  1055     	TUint8* data;

  1056 		TInt dataSize;

  1057 		//TUint oldMode = iTrace.Mode();

  1058 		//iTrace.SetMode(0); // turn off trace capture while we dump

  1059 		dataSize = iTrace.GetData(data);

  1060 		if(dataSize > 0)

  1061 			{

  1062 

  1063 	 		TPtrC8 dataPtr(data, dataSize);

  1064 			

  1065 	 		#if defined(__LIGHTLOGGER_ENABLED) && defined(__PERFORMANCE_TEST)

  1066  			__LOGTIMESTAMP_HIRES("Passing data to output framework - t2") //performance test

  1067 			#endif

  1068  			

  1069  			//send data through output channel

  1070  			TInt error = KErrNone;

  1071  			if((error = iOutputFramework->SendData(dataPtr)) == KErrNone)

  1072  				iTrace.DataUsed(); //only if data was really sent via output plugin

  1073  			else

  1074  				User::Leave(error);

  1075 	 		

  1076 			#if defined(__LIGHTLOGGER_ENABLED) && defined(__PERFORMANCE_TEST)

  1077 	 		__LOGTIMESTAMP_HIRES("Data logged - t3")	//performance test

  1078 			#endif

  1079 			}

  1080 		//iTrace.SetMode(oldMode);

  1081 			

  1082 		AsynchDataRequest();

  1083 	    } 

  1084     }

  1085 

  1086 

  1087 void CULoggerServer::AsynchDataRequest()

  1088 	{

  1089 	if(!iDataWatcher->IsActive())

  1090 		{

  1091 		iTrace.RequestData(iDataWatcher->GetStatus(), iDataNotification*1024); 

  1092 		iDataWatcher->StartWatching(this);

  1093 		}

  1094 	}

  1095 

  1096 

  1097 void CULoggerServer::DataNotification()

  1098 {

  1099 	TRAPD(e, ReadBufferL());

  1100 	if(e != KErrNone)

  1101 		AsynchDataRequest();

  1102 }

  1103 

  1104 

  1105 void CULoggerServer::GetPluginAndSettingsL(TDes8& aPluginName, RPointerArray<TPluginConfiguration>* aSettings, TPluginFilter aPluginFilter)

  1106 	{	

  1107 	TPtrC8 key;

  1108 	TPtrC8 val;

  1109 	RArray<TPtrC8> activePluginsArray;

  1110 	RArray<TPtrC8> pluginsArray;

  1111 	RArray<TPtrC8> pluginSettings;

  1112 	TInt i,j;

  1113 	

  1114 	if(aPluginFilter == EOutputPluginFilter)

  1115 		GetActiveOutputPlugin(activePluginsArray); //get output plugin

  1116 	else

  1117 		GetActiveInputPlugin(activePluginsArray); //get control plugin

  1118 	

  1119 	for(i=0; i<activePluginsArray.Count(); ++i)

  1120 		{

  1121 		TBuf8<256> activeplugin;

  1122 		activeplugin.Copy(activePluginsArray[i]);

  1123 		activeplugin.LowerCase();

  1124 		

  1125 		GetInstalledOutputPlugins(pluginsArray);

  1126 		for(j=0;j<pluginsArray.Count();j++)

  1127 			{

  1128 			TBuf8<256> plugin;

  1129 			plugin.Copy(pluginsArray[j]);

  1130 			plugin.LowerCase();

  1131 			

  1132 			if(activeplugin.Compare(plugin)==0)

  1133 				{

  1134 				break;