--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/traceservices/tracefw/ulogger/src/uloggerserver/uloggerserver.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,2081 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32const.h>
+#include <e32btrace.h>
+#include <f32file.h>
+#include "uloggerserver.h"
+#include "uloggersession.h"
+#include "uloggerclient.h"
+#include "uloggerplugin.h"
+#include "uloggershared.h"
+#include "uloggerdatatypes.h"
+#include "inputdata.h"
+#include "uloggercommands.h"
+
+#if defined(__LIGHTLOGGER_ENABLED)
+#include "lightlogger.h"
+#endif
+
+
+namespace Ulogger {
+
+
+/*Default constructor*/
+CULoggerServer::CULoggerServer(TInt aPriority)
+: CServer2( aPriority )
+
+{
+ iIsBooting = ETrue;
+ iConfigManager = NULL;
+ iDataWatcher = NULL;
+ iOutputFramework = NULL;
+ iInputFramework = NULL;
+ iPluginAllocator = NULL;
+}
+
+
+/** Destructor will be called before re-starting
+*/
+CULoggerServer::~CULoggerServer()
+{
+ delete iConfigManager;
+ delete iOutputFramework;
+ delete iInputFramework;
+ delete iPluginAllocator;
+ iPluginArray.ResetAndDestroy();
+ iPluginArray.Close();
+ if(iDataWatcher)
+ {
+ iDataWatcher->Cancel();
+ delete iDataWatcher;
+ }
+}
+
+/** Static Factory Construction
+@return a pointer to the created object
+@leave KErrNoMemory if not enough memory available
+*/
+CULoggerServer* CULoggerServer::NewLC(TInt aPriority)
+{
+ CULoggerServer* self = new (ELeave) CULoggerServer( aPriority );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+
+ return self;
+}
+
+/**
+Create and install new Framework & Active Scheduler
+*/
+void CULoggerServer::ConstructL()
+{
+ iRunAsService = EFalse; // Not used yet, to be used for run-as-service functionality
+ iBufferSize = KMaxBufferSize;
+ iBtraceOpen = EFalse;
+ iDataNotification = 0;
+
+ StartL( KServerName );
+ iConfigManager = CConfigFileManager::NewL();
+
+}
+
+
+/**
+Create a new server session.
+@note Called by kernel after client's thread use any of the macros for the first time.
+*/
+CSession2* CULoggerServer::NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const
+{
+ TVersion v(KULoggerSrvMajorVersionNumber,KULoggerSrvMinorVersionNumber,KULoggerSrvBuildVersionNumber);
+ if (!User::QueryVersionSupported(v,aVersion))
+ User::Leave(KErrNotSupported);
+
+ RThread client;
+ aMessage.Client(client);
+ return CULoggerSession::NewL( client, *const_cast<CULoggerServer*>(this) );
+}
+
+
+/*Increment session counter*/
+void CULoggerServer::IncrementSessions()
+{
+ ++iSessionCounter;
+}
+
+/*Decrement session counter*/
+void CULoggerServer::DecrementSessions()
+ {
+ if(--iSessionCounter <= 0)
+ {
+ if (!iBtraceOpen)
+ ShutDownServer();
+
+//
+// // Replace above if-statement with following to implement run-as-service functionality
+//
+// if((!iBtraceOpen) && (!iRunAsService))
+// ShutDownServer();
+//
+
+ }
+ }
+
+/*!
+Shuts down the server
+*/
+void CULoggerServer::ShutDownServer()
+{
+ CActiveScheduler::Stop();
+}//</ShutDownServer>
+
+
+
+
+/*!
+Return the error value
+*/
+TInt CULoggerServer::RunError(TInt aError)
+{
+ Message().Complete(aError);
+ ReStart();
+
+ return KErrNone;
+}
+
+
+
+
+void CULoggerServer::PanicServer(TULoggerSrvPanics aPanic)
+{
+ User::Panic(KServerName, aPanic);
+}//</PanicServer>
+
+
+
+/*!
+*/
+void CULoggerServer::PanicClient(const RMessage2& aMessage, TULoggerSrvPanics aPanic)
+{
+ aMessage.Panic( KServerName, aPanic );
+}//</PanicClient>
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ServerL
+@Installs the active scheduler
+@Opens the semaphore
+*/
+TInt CULoggerServer::StartServerL()
+{
+ #if defined(__LIGHTLOGGER_ENABLED)
+ __CREATE_LOG(EFalse)
+ __HIRES_RESOLUTION
+ #endif
+
+ CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler();
+ CleanupStack::PushL(activeScheduler) ;
+ CActiveScheduler::Install(activeScheduler);
+ CULoggerServer* server = NULL;
+ TInt servererr = KErrNone;
+ TRAP(servererr,
+ {
+ server = CULoggerServer::NewLC((TProcessPriority)EPriorityHigh);
+ CleanupStack::Pop();
+ });
+
+ if(servererr==KErrNone||servererr==KErrNotFound )
+ {
+ RProcess::Rendezvous(KErrNone);
+ servererr=KErrNone;
+ CActiveScheduler::Start();
+ }
+ else
+ {
+ RProcess::Rendezvous(servererr);
+ }
+ delete server;
+ CleanupStack::PopAndDestroy();
+ return servererr;
+
+}//</StartingFunctionL>
+
+
+/**
+Function to to start the server
+This should leave with KErrNone
+*/
+TInt CULoggerServer::StartServer()
+{
+ CTrapCleanup* cleanupStack = CTrapCleanup::New();
+ if (!cleanupStack)
+ {
+ return KErrNoMemory;
+ }
+ TInt err;
+ TRAP(err, StartServerL());
+
+ delete cleanupStack;
+ cleanupStack = NULL;
+
+ return err;
+}//</StartingFunction>
+
+
+/**
+Function to set the active output media
+This should leave with KErrNotFound if given plugin is not the correct one
+or the file doesn't exists in the user and public path
+*/
+
+TInt CULoggerServer::SetActiveOutputPlugin(const TDesC8 &aPluginname)
+{
+ RArray<TPtrC8> activePluginsArray;
+ TInt error= KErrNone;
+
+ error = GetInstalledOutputPlugins(activePluginsArray);
+ if(error==KErrNone)
+ {
+ for(TInt i=0;i<activePluginsArray.Count();i++)
+ {
+ if(aPluginname.Compare(activePluginsArray[i])==0)
+ {
+ error = iConfigManager->SetActiveOutputPlugin(aPluginname);
+ break;
+ }
+ else
+ error = KErrNotFound;
+ }
+ }
+ if(error == KErrAlreadyExists)
+ {
+ error=KErrNone;
+ }
+ return error;
+}
+
+
+TInt CULoggerServer::SetActiveInputPlugin(const TDesC8 &aPluginname)
+ {
+ RArray<TPtrC8> activePluginsArray;
+ TInt ret= KErrNone;
+ //check configuration file in user path (\\ulogger\\uloggerconfig.ini)
+
+ ret = GetInstalledInputPlugins(activePluginsArray);
+ if(ret==KErrNone)
+ {
+ ret = KErrNotFound;
+ for(TInt i=0;i<activePluginsArray.Count();i++)
+ {
+ if(aPluginname.Compare(activePluginsArray[i])==0)
+ {
+ ret = iConfigManager->SetActiveInputPlugin(aPluginname);
+ break;
+ }
+ }
+ }
+ return ret;
+ }
+
+
+/**
+Function to set the plugin settings
+This should leave with KErrNotFound if cannot file doesn't exist
+*/
+TInt CULoggerServer::SetPluginSettings(const TDesC8 &aPluginname, RArray<TPtrC8>& aListBuffer)
+{
+ TInt i = 0;
+ TInt ret=KErrNone;
+
+ //if plug-in doesn't exists
+ TPtrC8 pluginName(aPluginname);
+ if(!CheckPluginExists(pluginName, EOutputPluginFilter) && !CheckPluginExists(pluginName, EInputPluginFilter))
+ return KErrNotFound;
+
+ while(i<aListBuffer.Count())
+ {
+ TPtrC8 key(aListBuffer[i]);
+ TPtrC8 val(aListBuffer[++i]);
+ ret = iConfigManager->SetPluginSetting(aPluginname, key, val);
+ if(ret!=KErrNone)
+ break;
+ i++;
+ }
+ return ret;
+}
+
+
+
+
+/**
+Function to get the plugin settings
+This should leave with KErrNotFound if cannot find one
+*/
+TInt CULoggerServer::GetOptionsSettingsL(const TDesC8 &aMediaName, RArray<TPtrC8>& aListBuffer)
+{
+ //if plug-in doesn't exists
+ TPtrC8 pluginName(aMediaName);
+ if(!CheckPluginExists(pluginName, EOutputPluginFilter) && !CheckPluginExists(pluginName, EInputPluginFilter))
+ return KErrNotFound;
+ else
+ {
+ TInt ret = GetValues(aMediaName,aListBuffer);
+ if(ret == KErrNotFound) //this error indicate that there is no section in config file, plug-in exists
+ ret = KErrNone;
+ return ret;
+ }
+}
+
+
+
+/**
+Function to get values from the configuration file (i.e. for filters,plugin settings)
+This should leave with KErrNotFound if it cannot find the configuration file
+*/
+TInt CULoggerServer::GetValues(const TDesC8 &aSectionName, RArray<TPtrC8>& aListBuffer)
+{
+ TPtrC8 key;
+ TPtrC8 val;
+ TInt err = KErrNotFound;
+
+ Ulogger::CConfigSettingsIter* iter = Ulogger::CConfigSettingsIter::NewL();
+ CleanupStack::PushL(iter);
+
+ //check User configuration file if exists
+ //check values for given section in the configuration file
+ //if value exists copy it to array
+ err = iConfigManager->GetSectionValues(aSectionName,*iter);
+ if(err == KErrNone)
+ {
+ TBool found =EFalse;
+ while(iter->Next(key,val))
+ {
+ aListBuffer.AppendL(key);
+ aListBuffer.AppendL(val);
+ found = ETrue;
+ }
+ if(!found)
+ err = KErrNotFound;
+ }
+ CleanupStack::PopAndDestroy(); // list
+ return err;
+
+}
+
+
+/**
+Sets the Active Filter in the configuration file (primary and secondary filters)
+@aCategory filters to be set
+@aDupCategory duplicate filters which are not set
+@aFilter value that describes primary or secondary filter
+@return KErrNone, if successful, otherwise one of the other system-wide
+ error codes.
+*/
+TInt CULoggerServer::SetActiveFilter(RArray<TUint32> aCategory, TInt aFilterType)
+{
+ TInt error = KErrNone;
+ if(aFilterType == 1)
+ {
+ if(aCategory.Count()==0 || aCategory.Count()>KMaxPrimaryFiltersLimit)
+ error = KErrArgument;
+ else
+ {
+ error = iConfigManager->SetActiveFilter(aCategory,KPrimaryFilterSection);
+ if(error == KErrAlreadyExists)
+ error = KErrNone;
+ }
+ }
+ if(aFilterType == 2)
+ {
+ //we don't want to set more secondary filters than KMaxSecondaryFiltersLimit
+ RArray<TUint32> tmpArray;
+ CleanupClosePushL(tmpArray);
+ error = GetActiveFilters(tmpArray, ESecondaryFilter);
+ if(!error || error == KErrNotFound)
+ {
+ error = KErrNone; //in case it was KErrNotFound as it doesn't matter we didn't have any set already
+ if(aCategory.Count()==0 ||tmpArray.Count() > KMaxSecondaryFiltersLimit ||
+ (tmpArray.Count()+ aCategory.Count()) > KMaxSecondaryFiltersLimit)
+ error = KErrArgument;
+
+ }
+ CleanupStack::PopAndDestroy(); //tmpArray
+ if(!error)
+ error = iConfigManager->SetActiveFilter(aCategory,KSecondaryFilterSection);
+ }
+ return error;
+}
+
+
+/**
+Function to remove the Filter from config file
+@aFilter Filter to be removed
+@aValue primary or secondary filter to be removed
+This should leave with KErrNotFound if cannot find one or any system wide error codes
+*/
+TInt CULoggerServer::RemoveActiveFilter(RArray<TUint32>& aValue, const TInt aFilter)
+{
+ TInt ret = KErrNone;
+ //remove filter (primary or secondary) from BTrace current configuration
+ if(aFilter == EPrimaryFilter && (aValue.Count()==0 || aValue.Count()>KMaxPrimaryFiltersLimit))
+ return KErrArgument;
+ else if(aFilter == ESecondaryFilter && (aValue.Count()==0 || aValue.Count()>KMaxSecondaryFiltersLimit))
+ return KErrArgument;
+
+ ret = iConfigManager->RemoveActiveFilter(aValue,aFilter);
+ if(ret == KErrNotFound) //remove operation should succeed in this situation
+ ret = KErrNone;
+
+ return ret;
+}
+
+
+/**
+Function to set Trace settings to the configuration file
+@aValue value to be set
+@aSetting setting to which value to be set
+This should leave with KErrNotFound if cannot find one or any system wide error codes
+*/
+TInt CULoggerServer::SetTraceSettings(const TDesC8& aValue, const TDesC8& aSetting)
+ {
+ TInt r = iConfigManager->SetTraceSettings(aValue, aSetting);
+ return r;
+
+ }
+
+/**
+Function to remove plugin settings from the configuration file
+@aPluginName Plugin name whose settings has to be removed
+@return will return KErrNone or else leave with KErrNotFound
+ or any system wide error codes
+*/
+
+TInt CULoggerServer::RemovePluginSettingsL(const TDesC8 &aPluginName)
+ {
+ if(aPluginName.Length() == 0)
+ return KErrArgument;
+
+ TInt ret = KErrNone;
+ RArray<TPtrC8> settings;
+ ret = GetOptionsSettingsL(aPluginName, settings);
+ if(ret != KErrNone || settings.Count()==0)
+ ret = KErrNotFound;
+ settings.Close();
+
+ if(ret == KErrNone)
+ return iConfigManager->RemovePluginSettings(aPluginName);
+ else
+ return ret;
+ }
+
+/**
+Resize the BTrace buffer size
+
+@aSize The size to be set for the BTrace buffer.
+@return KErrNone, if successful, otherwise one of the other system-wide
+ error codes.
+*/
+TInt CULoggerServer::SetBufferSize(TInt aSize)
+ {
+ if(aSize > KMaxBufferSize || aSize < 1)
+ return KErrArgument;
+
+
+ //get dns to check
+ GetBufandDataNotifyValuesL(KDataNotification,iDataNotification);
+ if(aSize < iDataNotification)
+ return KErrGeneral;
+
+ iBufferSize = aSize;
+ HBufC8* Size = HBufC8::NewLC(32);
+ Size->Des().Num(iBufferSize);
+ CleanupStack::Pop(1);
+ TPtr8 ptr(Size->Des());
+ TInt r = iConfigManager->SetTraceSettings((const TDesC8&)ptr, KBuffer);
+ return r;
+ }
+
+
+/**
+Change the mode of the BTrace Buffer
+
+@aValue The mode to be set for the BTrace buffer.
+@return KErrNone, if successful, otherwise one of the other system-wide
+ error codes.
+*/
+TInt CULoggerServer::SetBufferMode(const TDesC8& aValue)
+ {
+
+ TInt r = SetTraceSettings(aValue, KBufferMode);
+ return r;
+ }
+
+/**
+Resize the Data Notification size
+
+@aSize The size to be set for the Data Notification size.
+@return KErrNone, if successful, otherwise one of the other system-wide
+ error codes.
+*/
+TInt CULoggerServer::SetDataNotificationSize(TInt aSize)
+ {
+ if(aSize > KMaxDnsSize || aSize < 0)
+ return KErrArgument;
+ TInt size, r;
+ TRAP_IGNORE((r=GetBufandDataNotifyValuesL(KBuffer,size)));
+ if(aSize > size)
+ return KErrGeneral;
+
+ iDataNotification = aSize;
+ HBufC8* Size = HBufC8::NewLC(32);
+ Size->Des().Num(aSize);
+ TPtr8 ptr(Size->Des());
+ r = SetTraceSettings((const TDesC8&)ptr, KDataNotification);
+ CleanupStack::PopAndDestroy();
+ return r;
+ }
+
+/**
+Function to retrieve the Trace Section Values
+This should leave with KErrNotFound if cannot find one
+as this should be treated as a corrupt config file
+*/
+void CULoggerServer::GetOptionsSettingsL(RArray<TPtrC8>& aListBuffer,const TDesC8& aSetting)
+{
+ TPtrC8 key;
+ TPtrC8 val;
+ TInt err=0;
+
+ Ulogger::CConfigSettingsIter* iter = Ulogger::CConfigSettingsIter::NewL();
+ CleanupStack::PushL(iter);
+ err=iConfigManager->GetPluginSettings(*iter);
+
+ if(err==KErrNone)
+ {
+ while(iter->Next(key,val))
+ {
+ if(key.Compare(aSetting)==0)
+ {
+ aListBuffer.AppendL(key);
+ aListBuffer.AppendL(val);
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy(); // list
+}
+
+/**
+Function to retrieve the active primary filters
+This should leave with KErrNotFound if cannot find one
+as this should be treated as a corrupt config file
+*/
+TInt CULoggerServer::GetBufandDataNotifyValuesL(const TDesC8& aSetting,TInt& value)
+ {
+ TInt err = KErrNotFound;
+ RArray<TPtrC8> traceValues;
+ TFileName filepath;
+
+ GetOptionsSettingsL(traceValues,aSetting);
+
+ value =-1;
+ //if values exists for the given trace settings
+ if(traceValues.Count()>1)
+ {// get values for buffer mode
+ if(aSetting.Compare(KBufferMode)==0)
+ {
+ err=KErrNone;
+ if(traceValues[1].Compare(KCircular) == 0)
+ value = ECircularBuffer;
+ else if(traceValues[1].Compare(KStraight) == 0)
+ value = EStraightBuffer;
+ else
+ err=KErrNotFound;
+ }
+ else
+ {// get values for data notification and buffer size
+ TLex8 lex_val(traceValues[1]);
+ err = lex_val.Val(value);
+ }
+ }
+ return err;
+ }
+
+
+
+/**
+Set the enable/disable secondary filters
+
+@aSize The size to be set for the BTrace buffer.
+@return KErrNone, if successful, otherwise one of the other system-wide
+ error codes.
+*/
+TInt CULoggerServer::SetSecondaryFiltering(const TDesC8& aEnabled)
+ {
+ TInt error = iConfigManager->SetTraceSettings(aEnabled, KSecondaryGlobalFilter);
+ if(error == KErrAlreadyExists)
+ error = KErrNone;
+ return error;
+
+ }
+
+
+/**
+Function to retrieve the active primary and secondary filters
+This should leave with KErrNotFound if cannot find one or any system wide error codes
+*/
+TInt CULoggerServer::GetActiveFilters(RArray<TUint32>& aListBuffer,TInt aFilterType)
+ {
+ TInt ret = KErrNotFound;
+ RArray<TPtrC8> aValues;
+ if(aFilterType == 1)
+ {
+ ret = GetValues(KPrimaryFilterSection,aValues);
+ if(ret==KErrNone)
+ {
+ TInt i =0;
+ TPtrC8 val;
+ TUint8 int_val;
+ while(i<aValues.Count())
+ {
+ TLex8 lex_val(aValues[++i]);
+ ret = lex_val.Val(int_val,EDecimal);
+ if(ret==KErrNone)
+ aListBuffer.Append(int_val);
+ else
+ return KErrCorrupt;
+ i++;
+ }
+ }
+ }
+ else if(aFilterType == 2)
+ {
+ ret = GetValues(KSecondaryFilterSection,aValues);
+ if(ret==KErrNone)
+ {
+ TInt i =0;
+ TPtrC8 val;
+ TUint int_val;
+ while(i<aValues.Count())
+ {
+ TLex8 lex_val(aValues[++i]);
+ ret = lex_val.Val(int_val,EDecimal);
+ if(ret==KErrNone)
+ aListBuffer.Append(int_val);
+ else
+ return KErrCorrupt;
+ i++;
+ }
+ }
+ else
+ {
+ if(ret==KErrNotFound)//i.e. if there are no values in the array --> change to if(filters.Count = 0)?
+ ret=KErrNone;
+ }
+ }
+ return ret;
+ }
+
+/**
+Function to retrieve the active secondary global filter
+This should leave with KErrNotFound if cannot find one
+*/
+
+TInt CULoggerServer::GetSecondaryFiltering(TBool& aEnabled)
+{
+ RArray<TPtrC8> configSettings;
+ TRAPD(error, GetOptionsSettingsL(configSettings,KSecondaryGlobalFilter));
+ if(configSettings[1]==KEnable) //First element contains KSecondaryGlobalFilter, second the value
+ aEnabled = ETrue;
+ if(configSettings[1]==KDisable)
+ aEnabled = EFalse;
+ return error;
+}
+
+/**
+Function to retrieve the plugin names from the ECOM framework
+This should leave with KErrNotFound if cannot find one
+*/
+TInt CULoggerServer::GetInstalledOutputPlugins(RArray<TPtrC8>& aListBuffer)
+ {
+ // Read info about all implementations into infoArray
+ // Note that a special cleanup function is required to reset and destroy
+ // all items in the array, and then close it.
+ if(iPluginArray.Count()>0)
+ {
+ iPluginArray.ResetAndDestroy();
+ iPluginArray.Close();
+ }
+
+ TRAPD(error,CPluginAllocator::ListAllImplementationsL(iPluginArray));
+
+ if(iPluginArray.Count()>0)
+ {
+ for (TInt i=0; i< iPluginArray.Count(); i++)
+ {
+ TRAP(error,aListBuffer.AppendL(iPluginArray[i]->DataType()));
+ }
+
+ //filter plugins and to use only output plugins
+ FilterPlugins(EOutputPluginFilter, aListBuffer);
+ }
+
+ return error;
+ }
+
+
+
+TInt CULoggerServer::GetInstalledInputPlugins(RArray<TPtrC8>& aListBuffer)
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __MARK_METHOD("CULoggerServer::GetInstalledControlPlugins")
+ #endif
+
+ if(iPluginArray.Count()>0)
+ {
+ iPluginArray.ResetAndDestroy();
+ iPluginArray.Close();
+ }
+ // Read info about all implementations into infoArray
+ // Note that a special cleanup function is required to reset and destroy
+ // all items in the array, and then close it.
+ CPluginAllocator::ListAllImplementationsL(iPluginArray);
+
+ if(iPluginArray.Count() > 0)
+ {
+ for (TInt i=0; i< iPluginArray.Count(); i++)
+ aListBuffer.AppendL(iPluginArray[i]->DataType());
+
+ //filter plugins and to use only output plugins
+ FilterPlugins(EInputPluginFilter, aListBuffer);
+ }
+ return KErrNone;
+ }
+
+
+/**
+Function to retrieve the Active plugin name
+This should leave with KErrNotFound if cannot find one or any system wide error codes
+*/
+TInt CULoggerServer::GetActiveOutputPlugin(RArray<TPtrC8>& aListBuffer)
+ {
+ TInt errCode = GetValues(KActiveSection,aListBuffer);
+ //plugins are received as, e.g. '1 uloggerfileplugin' (.ini file syntax)
+ //we have to remove number from array
+ for(TInt i=0; i<aListBuffer.Count(); ++i)
+ {
+ TInt v;
+ TLex8 lex(aListBuffer[i]);
+ if(lex.Val(v) == KErrNone)
+ {
+ aListBuffer.Remove(i);
+ i=-1; //start from begin, i will be incremented in loop
+ }
+ }
+ return errCode;
+ }
+
+
+/**
+Function to Deactivate or remove active output plugin
+This should leave with KErrNotFound if cannot find one or any system wide error codes
+*/
+
+TInt CULoggerServer::DeActivateOutputPlugin(const TDesC8 &aPluginname)
+{
+ if(iBtraceOpen != EFalse)
+ {
+ Stop();
+ iBtraceOpen = EFalse;
+ }
+
+ TInt ret = iConfigManager->DeActivateOutputPlugin(aPluginname);
+ return ret;
+}
+
+/**
+Function to retrieve the Active control plugin name
+This should leave with KErrNotFound if cannot find one or any system wide error codes
+*/
+TInt CULoggerServer::GetActiveInputPlugin(RArray<TPtrC8>& aListBuffer)
+ {
+ return GetValues(KActiveControlSection,aListBuffer);
+ }
+
+/**
+Function to Deactivate active control plugin
+This should leave with KErrNotFound if cannot find one or any system wide error codes
+*/
+TInt CULoggerServer::DeActivateInputPlugin(const TDesC8& aPluginname)
+ {
+ return iConfigManager->DeActivateInputPlugin(aPluginname);
+ }
+
+/**
+Function to run ULogger server as service, i.e. to keep it constantly running
+(but not necessarily logging) in the background, or to stop it being run as a
+service (if EFalse is passed).
+
+@param aRunAsService ETrue to start, EFalse to stop running as service
+*/
+void CULoggerServer::RunAsService(TBool /*aRunAsService*/)
+ {
+//
+// // Uncomment following to implement run-as-service functionality
+//
+// iRunAsService = aRunAsService;
+//
+// if (!aRunAsService)
+// {
+// //make sure server is stopped if there are no sessions
+// IncrementSessions();
+// DecrementSessions();
+// }
+ }
+
+/**
+Function to cd.. ulogger server
+This should leave with KErrNotFound if cannot find one or any system wide error codes
+*/
+TInt CULoggerServer::Start()
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __MARK_METHOD("CULoggerServer::Start")
+ #endif
+
+ TRAPD(error, InitializeFrameworksL());
+
+ //check errors
+ if(error != KErrNone)
+ return error;
+ if(!iOutputFramework)
+ return KErrNotReady;
+ if(iBtraceOpen)
+ return KErrInUse;
+
+ TPtrC8 key;
+ TPtrC8 val;
+ TInt buffermode=0;
+ RArray<TPtrC8> settings;
+ RArray<TUint32> activefilters;
+ //checking if there is at least one active channel
+ error = GetActiveOutputPlugin(settings);
+ if(error != KErrNone)
+ return error;
+ if(settings.Count()==0)
+ {
+ return KErrNotFound; //active output plug-in not found
+ }
+
+ if(iBtraceOpen == EFalse)
+ {
+ if(iIsBooting)
+ error = TraceSettingsOnBoot();
+ else
+ error = iTrace.Open();
+
+ if(error == KErrNone)
+ {
+ //----Reset the notification size
+ TRAP_IGNORE(error=GetBufandDataNotifyValuesL(KDataNotification,iDataNotification));
+ if(error!=KErrNone)
+ return error;
+ TRAP_IGNORE(error=GetBufandDataNotifyValuesL(KBuffer,iBufferSize));
+ if(error!=KErrNone)
+ return error;
+
+ //----Reset BTrace filters
+ ResetBtracePrimaryFilters(iTrace);
+
+ //----Resize the trace buffer
+ error = iTrace.ResizeBuffer(iBufferSize*1024);
+ if(error == KErrNoMemory)
+ {
+ error = iTrace.ResizeBuffer(KMinBufferMTPLE*1024);
+ }
+ if(error != KErrNone)
+ return error;
+ //----Reset the buffer mode
+ TRAP_IGNORE(GetBufandDataNotifyValuesL(KBufferMode,buffermode));
+ if(buffermode==ECircularBuffer)
+ {
+ iTrace.SetMode(RBTrace::EFreeRunning|RBTrace::EEnable);
+ }
+ else
+ {
+ iTrace.SetMode(RBTrace::EEnable);
+ }
+
+ //----Enable/disable primary filter
+ error = GetActiveFilters(activefilters,EPrimaryFilter);
+ if(error != KErrNone)
+ return error;
+ for(TInt i=0; i<activefilters.Count(); ++i)
+ {
+ TUint filter;
+ filter= (TUint8)activefilters[i];
+ iTrace.SetFilter(filter,ETrue);
+ }
+
+ //----Enable/disable secondary filter
+ settings.Reset();
+ TBool enabled = EFalse;
+ error = GetSecondaryFiltering(enabled);
+ if(!error)
+ {
+ if (enabled)//enable secondary filter, only traces with certain value will pass
+ {
+ iTrace.SetFilter2(0);
+
+ //enable secondary filters chosen by user
+ activefilters.Reset();
+ if((error = GetActiveFilters(activefilters,ESecondaryFilter)) == KErrNone)
+ for(TInt i=0; i<activefilters.Count(); ++i)
+ iTrace.SetFilter2(activefilters[i], ETrue);
+ else
+ {
+ if(error == KErrNotFound)
+ {
+ error = KErrNone;
+ }
+ else
+ return error;
+ }
+ }
+ else//disable secondary filter, all traces will pass
+ {
+ iTrace.SetFilter2(1);
+ }
+ }
+
+ //set flag to idicate that btrace is open
+ iBtraceOpen = ETrue;
+
+ //start input and output frameworks
+ iInputFramework->StartReading(); //start waiting for remote commands
+ AsynchDataRequest();
+ }
+ }
+ else
+ error = KErrInUse;
+
+ return error;
+ }
+
+/**
+Close the BTrace handle to the buffer
+@return none
+*/
+TInt CULoggerServer::Stop()
+{
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __MARK_METHOD("CULoggerServer::Stop")
+ #endif
+
+ if(iBtraceOpen)
+ {
+ TInt errCode = KErrNone;
+ TRAP(errCode, ReadBufferL()); //flush the BTrace buffer
+
+ ResetBtracePrimaryFilters(iTrace);//reset BTrace filters
+
+ iTrace.CancelRequestData();
+ iTrace.Empty();
+ iTrace.Close();
+ iBtraceOpen = EFalse;
+ iDataWatcher->Cancel();
+
+ //stop waiting/reading for remote commands
+ iInputFramework->StopReading();
+ iOutputFramework->ReleaseOutputResources();
+ return KErrNone;
+ }
+ else
+ {
+ return KErrNotReady;
+ }
+
+}
+
+/**
+Gets the Trace settings on boot
+@return none
+*/
+TInt CULoggerServer::TraceSettingsOnBoot()
+{
+
+ TInt trace = FALSE;
+
+ RArray<TUint32> category;
+ TInt error = iTrace.Open();
+ if(error != KErrNone)
+ return error;
+
+ TInt bufferSize = iTrace.BufferSize(); //To get the buffer size set at boot
+ if(bufferSize <= 0 && bufferSize > KMaxBufferSize)
+ SetBufferSize(KMaxBufferSize); //Update config
+ else
+ SetBufferSize(bufferSize); //Update config
+ for(TUint i=0; i<KMaxPrimaryFiltersLimit; i++)
+ {
+ trace = iTrace.Filter(i);
+ if(trace == 1)
+ category.AppendL((TUint32)i);
+ }
+ error = iConfigManager->SetActiveFilter(category,KPrimaryFilterSection);
+ category.Close();
+ iIsBooting=0;
+ return error;
+}
+
+
+
+/**
+Reads the BTrace buffer and transfers the collected logs to
+the ACTIVE channel
+*/
+void CULoggerServer::ReadBufferL()
+ {
+ if(iBtraceOpen)
+ {
+ TUint8* data;
+ TInt dataSize;
+ //TUint oldMode = iTrace.Mode();
+ //iTrace.SetMode(0); // turn off trace capture while we dump
+ dataSize = iTrace.GetData(data);
+ if(dataSize > 0)
+ {
+
+ TPtrC8 dataPtr(data, dataSize);
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__PERFORMANCE_TEST)
+ __LOGTIMESTAMP_HIRES("Passing data to output framework - t2") //performance test
+ #endif
+
+ //send data through output channel
+ TInt error = KErrNone;
+ if((error = iOutputFramework->SendData(dataPtr)) == KErrNone)
+ iTrace.DataUsed(); //only if data was really sent via output plugin
+ else
+ User::Leave(error);
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__PERFORMANCE_TEST)
+ __LOGTIMESTAMP_HIRES("Data logged - t3") //performance test
+ #endif
+ }
+ //iTrace.SetMode(oldMode);
+
+ AsynchDataRequest();
+ }
+ }
+
+
+void CULoggerServer::AsynchDataRequest()
+ {
+ if(!iDataWatcher->IsActive())
+ {
+ iTrace.RequestData(iDataWatcher->GetStatus(), iDataNotification*1024);
+ iDataWatcher->StartWatching(this);
+ }
+ }
+
+
+void CULoggerServer::DataNotification()
+{
+ TRAPD(e, ReadBufferL());
+ if(e != KErrNone)
+ AsynchDataRequest();
+}
+
+
+void CULoggerServer::GetPluginAndSettingsL(TDes8& aPluginName, RPointerArray<TPluginConfiguration>* aSettings, TPluginFilter aPluginFilter)
+ {
+ TPtrC8 key;
+ TPtrC8 val;
+ RArray<TPtrC8> activePluginsArray;
+ RArray<TPtrC8> pluginsArray;
+ RArray<TPtrC8> pluginSettings;
+ TInt i,j;
+
+ if(aPluginFilter == EOutputPluginFilter)
+ GetActiveOutputPlugin(activePluginsArray); //get output plugin
+ else
+ GetActiveInputPlugin(activePluginsArray); //get control plugin
+
+ for(i=0; i<activePluginsArray.Count(); ++i)
+ {
+ TBuf8<256> activeplugin;
+ activeplugin.Copy(activePluginsArray[i]);
+ activeplugin.LowerCase();
+
+ GetInstalledOutputPlugins(pluginsArray);
+ for(j=0;j<pluginsArray.Count();j++)
+ {
+ TBuf8<256> plugin;
+ plugin.Copy(pluginsArray[j]);
+ plugin.LowerCase();
+
+ if(activeplugin.Compare(plugin)==0)
+ {
+ break;
+ }
+ }
+ aPluginName.Copy(activePluginsArray[i]);
+ GetOptionsSettingsL(aPluginName,pluginSettings);
+ j=0;
+ while(j < pluginSettings.Count())
+ {
+ TPluginConfiguration* keyAndVal = new TPluginConfiguration();
+ keyAndVal->SetKey(pluginSettings[j]);
+ keyAndVal->SetValue(pluginSettings[j+1]);
+ aSettings->AppendL(keyAndVal);
+ j=j+2;
+ }
+ }
+ }
+
+
+void CULoggerServer::InitializeFrameworksL()
+ {
+ //<create plugin allocator (plugins)>
+ //output settings
+ RBuf8 outPluginName;
+ outPluginName.Create(KMaxPluginName);
+ RPointerArray<TPluginConfiguration> outputPluginSettings;
+ GetPluginAndSettingsL(outPluginName, &outputPluginSettings, EOutputPluginFilter);
+
+ //control settings
+ RBuf8 inputPluginName;
+ inputPluginName.Create(KMaxPluginName);
+ RPointerArray<TPluginConfiguration> inputPluginSettings;
+ this->GetPluginAndSettingsL(inputPluginName, &inputPluginSettings, EInputPluginFilter);
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("before creating CPluginAllocator")
+ #endif
+
+ //create plugin allocator (plugins)
+ if(!iPluginAllocator)
+ iPluginAllocator = CPluginAllocator::NewL(outPluginName, inputPluginName);
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("before creating COutputFramework")
+ #endif
+ //Initialize output framework
+ if(!iOutputFramework)
+ iOutputFramework = COutputFramework::NewL(*(iPluginAllocator->GetOutputPlugin()), outputPluginSettings);
+
+ //Initialize Control Framework
+ if(!iInputFramework)
+ iInputFramework = CInputFramework::NewL(iPluginAllocator->GetInputPlugin(), inputPluginSettings, this);
+
+ //cleanup
+ outPluginName.Close();
+ outputPluginSettings.ResetAndDestroy();
+ outputPluginSettings.Close();
+ inputPluginName.Close();
+ inputPluginSettings.ResetAndDestroy();
+ inputPluginSettings.Close();
+
+ iDataWatcher = CULoggerWatcher::NewL();
+ }
+
+
+void CULoggerServer::PrepareControlDataPayloadL(RBuf8& aPayloadBuf, const RArray<TPtrC8>& aArray)
+ {
+ aPayloadBuf.Create(aArray.Count()*32);
+ for(TInt i=0; i<aArray.Count(); i++)
+ {
+ if(aPayloadBuf.MaxSize() < aPayloadBuf.Length()+aArray[i].Length())
+ aPayloadBuf.ReAllocL(aPayloadBuf.Length()+(aArray[i].Length()*10));
+ aPayloadBuf.Append(aArray[i]);
+ if(i < aArray.Count()-1) //skip last sparator as it will be added automatically
+ aPayloadBuf.Append(DATA_SEPARATOR);
+ }
+ }
+
+
+void CULoggerServer::PrepareControlDataPayloadL(RBuf8& aPayloadBuf, const RArray<TUint32>& aArray)
+ {
+ aPayloadBuf.Create(aArray.Count()*4);
+ for(TInt i=0; i<aArray.Count(); i++)
+ {
+ TBuf8<64> b;
+ b.Num(aArray[i]);
+ if(aPayloadBuf.MaxSize() < aPayloadBuf.Length()+b.Length())
+ aPayloadBuf.ReAllocL(aPayloadBuf.Length()+(b.Length()*10));
+ aPayloadBuf.Append(b);
+ if(i < aArray.Count()-1) //skip last sparator as it will be added automatically
+ aPayloadBuf.Append(DATA_SEPARATOR);
+ }
+ }
+
+
+TInt CULoggerServer::RestartOutputting()
+ {
+ TInt err=KErrNone;
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __MARK_METHOD("CULoggerServer::ForceRefreshSettingsL")
+ #endif
+ if(iBtraceOpen != EFalse)
+ {
+ err = Stop();
+ iBtraceOpen = EFalse;
+ }
+
+ if(iDataWatcher)
+ {
+ iDataWatcher->Cancel();
+ delete iDataWatcher;
+ iDataWatcher = NULL;
+ }
+ if(iOutputFramework)
+ {
+ delete iOutputFramework;
+ iOutputFramework = NULL;
+ }
+ if(iInputFramework)
+ {
+ delete iInputFramework;
+ iInputFramework = NULL;
+ }
+ if(iPluginAllocator)
+ {
+ delete iPluginAllocator;
+ iPluginAllocator = NULL;
+ }
+ if(iConfigManager)
+ {
+ iConfigManager->RefreshConfigFiles();
+ }
+
+ err = Start(); //always start
+ return err;
+ }
+
+
+TInt CULoggerServer::ResetBtracePrimaryFilters(RBTrace &aBTrace)
+ {
+ for(TUint i=0; i<256; i++)
+ aBTrace.SetFilter(i, EFalse);
+ aBTrace.SetFilter2(0);
+ return KErrNone;
+ }
+
+//This bit should be part of the input framework, or it should reuse the other methods better
+ControlData* CULoggerServer::ProcessCommandL(TCommand aOpCode, RArray<TPtrC8> &aArguments)
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __MARK_METHOD("CULoggerServer::ProcessCommand")
+ #endif
+
+ TInt errCode = KErrNone;
+ TInt minSize = 8;
+ CInputData *inputData = new (ELeave) CInputData(minSize);
+ ControlData* data = NULL;
+ RBuf8 payloadBuf;
+ TBuf8<32> result;
+
+ switch(aOpCode)
+ {
+ case EStart:
+ {
+ if(!ServerState())
+ errCode = this->Start();
+ else
+ errCode = KErrInUse;
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case EStop:
+ {
+ //ulogger shouldn't be restarted here as we must send acknowledgment back to PC
+ //Stop will be done in DoPostProcessing method after sending ack.
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case ESetPrimaryFilter:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("ESetPrimaryFilter")
+ #endif
+
+ RArray<TUint32> filterArray;
+
+ errCode = KErrNone;
+ //process parameters
+ TInt i;
+ for(i=0; i<aArguments.Count(); i++)
+ {
+ TUint8 val;
+ TLex8 lex(aArguments[i]);
+ if((errCode=lex.Val(val, EDecimal)) != KErrNone)
+ {
+ //report bad values, don't set anything
+ if(errCode == KErrGeneral)
+ errCode = KErrArgument;
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ /*
+ payloadBuf.Create(128);
+ payloadBuf.Copy(aArguments[i]);
+ inputData->AppendNewData(ack, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ */
+ filterArray.Close();
+ break;
+ }
+ filterArray.AppendL(val);
+ }
+
+ if(errCode == KErrNone)
+ {
+ errCode = SetActiveFilter(filterArray, EPrimaryFilter);
+ result.Num(errCode);
+
+ //create acknowledment
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+
+ //create string as a payload
+ /*
+ payloadBuf.Create(dupfilterArray.Count()*4);
+ for(i=0; i<dupfilterArray.Count(); i++)
+ {
+ TBuf8<32> b;
+ b.Num(dupfilterArray[i]);
+ if(payloadBuf.MaxSize() < payloadBuf.Length()+b.Length())
+ payloadBuf.ReAllocL(payloadBuf.Length()+(b.Length()*10));
+ payloadBuf.Append(b);
+ if(i < dupfilterArray.Count()-1) //skip last sparator as it will be added automatically
+ payloadBuf.Append(DATA_SEPARATOR);
+ }
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(ack, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ */
+ filterArray.Close();
+ }
+ }
+ break; //ESetPrimaryFilter
+
+ case ESetSecondaryFilter:
+ {
+ RArray<TUint32> filterArray;
+ //process parameters
+ TInt i;
+ for(i=0; i<aArguments.Count(); i++)
+ {
+ TUint32 val;
+ TLex8 lex(aArguments[i]);
+ if((errCode=lex.Val(val,EDecimal)) != KErrNone)
+ {
+ //report bad values, don't set anything
+ if(errCode == KErrGeneral)
+ errCode = KErrArgument;
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ /*
+ payloadBuf.Create(128);
+ payloadBuf.Copy(aArguments[i]);
+ man->AppendNewData(ack, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ */
+ filterArray.Close();
+ break;
+ }
+ filterArray.AppendL(val);
+ }
+ if(errCode != KErrNone)
+ break;
+
+ //create ack
+ errCode = SetActiveFilter(filterArray, ESecondaryFilter);
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+
+ filterArray.Close();
+ }
+ break; //ESetSecondaryFilter
+
+ case EEnableSecondaryFiltering:
+ {
+ errCode = SetSecondaryFiltering(KEnable);
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case EDisableSecondaryFiltering:
+ {
+ errCode = SetSecondaryFiltering(KDisable);
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case EResizeTraceBuffer:
+ {
+ if(aArguments.Count() > 0)
+ {
+ TInt bufSize;
+ TLex8 lex(aArguments[0]);
+ if((errCode = lex.Val(bufSize)) == KErrNone)
+ errCode = SetBufferSize(bufSize);
+ }
+ else
+ errCode = KErrArgument;
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case ESetBufferMode:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("ESetBufferMode")
+ #endif
+
+ if(aArguments.Count() > 0)
+ {
+ if(aArguments[0].Compare(KCircular)==0)
+ errCode = SetBufferMode(KCircular);
+ else if(aArguments[0].Compare(KStraight)==0)
+ errCode = SetBufferMode(KStraight);
+ else
+ errCode = KErrArgument;
+ }
+ else
+ errCode = KErrArgument;
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("errCode")
+ __LOGNUM(errCode)
+ #endif
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case ESetDataNotificationSize:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("ESetDataNotificationSize")
+ #endif
+
+ if(aArguments.Count() > 0)
+ {
+ TInt dns;
+ TLex8 lex(aArguments[0]);
+ if((errCode = lex.Val(dns)) == KErrNone)
+ errCode = SetDataNotificationSize(dns);
+ else
+ errCode = KErrArgument;
+ }
+ else
+ errCode = KErrArgument;
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case ERemovePluginSettings:
+ {
+ if(aArguments.Count() > 0)
+ errCode = RemovePluginSettingsL(aArguments[0]);
+ else
+ errCode = KErrArgument;
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case EGetInstalledPlugins:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetInstalledOutputPlugins")
+ #endif
+
+ RArray<TPtrC8> tmpArray;
+ errCode = GetInstalledOutputPlugins(tmpArray);
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ for(TInt p=0; p<tmpArray.Count(); p++) __LOGBUF(tmpArray[p])
+ #endif
+
+ //create payload
+ PrepareControlDataPayloadL(payloadBuf, tmpArray);
+ //add playload in control data chunk
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(data, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ }
+ break; //EGetInstalledOutputPlugins
+
+ case EGetActivePlugin: //output
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetActivePlugin")
+ #endif
+
+ RArray<TPtrC8> tmpArray;
+ errCode = GetActiveOutputPlugin(tmpArray);
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ for(TInt p=0; p<tmpArray.Count(); p++) __LOGBUF(tmpArray[p])
+ #endif
+
+ //create payload
+ PrepareControlDataPayloadL(payloadBuf, tmpArray);
+ //add playload in control data chunk
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(data, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ }
+ break; //EGetActivePlugin
+
+ case EGetPluginSettings:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetPluginSettings")
+ #endif
+ RArray<TPtrC8> tmpArray;
+ if(aArguments.Count() > 0)
+ {
+ errCode = GetOptionsSettingsL(aArguments[0],tmpArray);
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ for(TInt p=0; p<tmpArray.Count(); p++) __LOGBUF(tmpArray[p])
+ #endif
+ }
+ else
+ errCode = KErrArgument;
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ //create payload
+ PrepareControlDataPayloadL(payloadBuf, tmpArray);
+ //add playload in control data chunk
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(data, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ }
+ break; //EGetPluginSettings
+
+ case EGetPrimaryFilters:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetPluginSettings")
+ #endif
+
+ RArray<TUint32> tmpArray;
+ errCode = GetActiveFilters(tmpArray,EPrimaryFilter);
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ for(TInt p=0; p<tmpArray.Count(); p++) __LOGNUM(tmpArray[p])
+ #endif
+
+ //create payload
+ PrepareControlDataPayloadL(payloadBuf, tmpArray);
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetPluginSettings - test 1")
+ #endif
+
+
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(data, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ tmpArray.Close();
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetPluginSettings - test 2")
+ #endif
+ }
+ break; //EGetPrimaryFilters
+
+ case EGetSecondaryFilters:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetSecondaryFilters")
+ #endif
+
+ TBool skipReadingFilters = EFalse;
+ RArray<TPtrC8> tmpArrayTxt;
+ TBool enabled = EFalse;
+ errCode = errCode = this->GetSecondaryFiltering(enabled);
+ if(errCode == KErrNone)
+ {
+ if(EFalse == enabled)
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ skipReadingFilters = ETrue;
+ //create payload
+ PrepareControlDataPayloadL(payloadBuf, tmpArrayTxt);
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(data, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ }
+ }
+
+ RArray<TUint32> tmpArray;
+ if(!skipReadingFilters)
+ {
+ errCode = this->GetActiveFilters(tmpArray,ESecondaryFilter);
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ //create payload
+ PrepareControlDataPayloadL(payloadBuf, tmpArray);
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(data, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ }
+
+ tmpArrayTxt.Close();
+ tmpArray.Close();
+ }
+ break; //EGetSecondaryFilters
+
+ case EGetSecondaryFiltering:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetSecondaryFiltering")
+ #endif
+
+ TBool enabled = EFalse;
+ errCode = GetSecondaryFiltering(enabled);
+ if(errCode == KErrNone)
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+
+ //create payload
+ TBuf8<32> b;
+ b.Num(enabled);
+ inputData->AppendNewData(data, (const void*)b.Ptr(), b.Length());
+ }
+ else
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ }
+ break; //EGetSecondaryFiltering
+
+ //this functionality is removed now
+ /*
+ case ESetSecondaryFilterCurrent:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("ESetSecondaryFilterCurrent")
+ #endif
+
+ errCode = this->SetSecondaryFiltering(KCurrent);
+ result.Num(errCode);
+ ack = man->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break; //ESetSecondaryFilterCurrent
+ */
+ case EGetTraceBufferSize:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetTraceBufferSize")
+ #endif
+
+ TInt bufferSize = 0;
+ errCode = GetBufandDataNotifyValuesL(KBuffer,bufferSize);
+ if(errCode == KErrNone)
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ TBuf8<32> b;
+ b.Num(bufferSize);
+ inputData->AppendNewData(data, (const void*)b.Ptr(), b.Length());
+ }
+ else
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ }
+ break; //EGetTraceBufferSize
+
+ case EGetBufferMode:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetBufferMode")
+ #endif
+
+ TInt bufferMode = 3;
+ errCode = GetBufandDataNotifyValuesL(KBufferMode,bufferMode);
+ if(errCode == KErrNone)
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+
+ result.Zero();
+ if(bufferMode == 0)
+ result.Append(KCircular);
+ else if(bufferMode == 1)
+ result.Append(KStraight);
+ else
+ result.Append(_L8("Invalid mode"));
+
+ inputData->AppendNewData(data, (const void*)result.Ptr(), result.Length());
+ }
+ else
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ }
+ break; //EGetBufferMode
+
+ case EGetDataNotificationSize:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetDataNotificationSize")
+ #endif
+
+ TInt dataNotification = 0;
+ errCode = GetBufandDataNotifyValuesL(KDataNotification,dataNotification);
+ if(errCode == KErrNone)
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ TBuf8<32> b;
+ b.Num(dataNotification);
+ inputData->AppendNewData(data, (const void*)b.Ptr(), b.Length());
+ }
+ else
+ {
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ }
+ break; //EGetDataNotificationSize
+
+ case ERemovePrimaryFilter:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("ERemovePrimaryFilter")
+ for(TInt k=0; k<aArguments.Count(); k++)
+ {
+ __LOGBUF(aArguments[k])
+ }
+ #endif
+
+ if(aArguments.Count() > 0)
+ {
+ RArray<TUint32> filterArray;
+ for(TInt i=0; i<aArguments.Count(); i++)
+ {
+ TUint32 val;
+ TLex8 lex(aArguments[i]);
+ if(lex.Val(val, EDecimal) == KErrNone)
+ filterArray.AppendL(val);
+ }
+ errCode = RemoveActiveFilter(filterArray,EPrimaryFilter);
+ filterArray.Close();
+ }
+ else
+ errCode = KErrArgument;
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break; //ERemovePrimaryFilter
+
+ case ERemoveSecondaryFilter:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EDisableMultipleModuleUids")
+ for(TInt k=0; k<aArguments.Count(); k++)
+ {
+ __LOGBUF(aArguments[k])
+ }
+ #endif
+
+ if(aArguments.Count() > 0)
+ {
+ RArray<TUint32> filterArray;
+ for(TInt i=0; i<aArguments.Count(); i++)
+ {
+ TUint32 val;
+ TLex8 lex(aArguments[i]);
+ if(lex.Val(val, EDecimal) == KErrNone)
+ filterArray.AppendL(val);
+ }
+ errCode = RemoveActiveFilter(filterArray,ESecondaryFilter);
+ filterArray.Close();
+ }
+ else
+ errCode = KErrArgument;
+
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("errCode:")
+ __LOGNUM(errCode)
+ #endif
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break; //ERemoveSecondaryFilter
+
+ case ESetPluginSettings:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("ESetPluginSettings")
+ #endif
+
+ if(aArguments.Count() > 2)
+ {
+ TBuf8<128> plugin;
+ plugin.Copy(aArguments[0]);
+ aArguments.Remove(0);
+ errCode = SetPluginSettings(plugin, aArguments);
+ }
+ else
+ errCode = KErrArgument;
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break; //ESetChannelSettings
+
+ case ESetActivePlugin:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("ESetActiveOutputPlugin")
+ #endif
+
+ if(aArguments.Count() > 0)
+ errCode = SetActiveOutputPlugin(aArguments[0]);
+ else
+ errCode = KErrArgument;
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break; //ESetActiveOutputPlugin
+
+ case ESetActiveInputPlugin:
+ {
+ if(aArguments.Count() > 0)
+ errCode = SetActiveInputPlugin(aArguments[0]);
+ else
+ errCode = KErrArgument;
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case EDeactivateInputPlugin:
+ {
+ if(aArguments.Count() > 0)
+ errCode = DeActivateInputPlugin(aArguments[0]);
+ else
+ errCode = KErrArgument;
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ case EGetActiveInputPlugin:
+ {
+ RArray<TPtrC8> tmpArray;
+ errCode = GetActiveInputPlugin(tmpArray);
+ result.Num(errCode);
+
+ //remove ini specific data (number)
+ //example (1 uloggerusbplugin) must look like (uloggerusbplugin)
+ TInt i=0;
+ while(i<tmpArray.Count())
+ {
+ TInt v = 0;
+ TLex8 l(tmpArray[i]);
+ if(l.Val(v) == KErrNone)
+ tmpArray.Remove(i);
+ else
+ ++i;
+ }
+
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ PrepareControlDataPayloadL(payloadBuf, tmpArray);
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(data, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ tmpArray.Close();
+ }
+ break;
+
+ case EGetInputPlugins:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("EGetControlPlugins")
+ #endif
+
+ RArray<TPtrC8> tmpArray;
+ errCode = GetInstalledInputPlugins(tmpArray);
+
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+
+ //create payload
+ PrepareControlDataPayloadL(payloadBuf, tmpArray);
+ //add playload to control data chunk
+ if(payloadBuf.Length() > 0)
+ inputData->AppendNewData(data, (const void*)payloadBuf.Ptr(), payloadBuf.Length());
+ tmpArray.Close();
+ }
+ break;
+
+ case ERestart:
+ {
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("ERestartOutputting")
+ #endif
+
+ //ulogger shouldn't be restarted here as we must send acknowledgment back to PC
+ //restart will be done in DoPostProcessing method after sending ack.
+ result.Num(errCode);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ }
+ break;
+
+ default:
+ #if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)
+ __LOG("input command not supported")
+ #endif
+
+ result.Num(KErrNotSupported);
+ data = inputData->CreatePackage((void*)result.Ptr(), result.Length());
+ break;
+ }//end of switch
+
+
+ //cleanup
+ if(inputData)
+ {
+ delete inputData;
+ inputData = NULL;
+ }
+ payloadBuf.Close();
+
+ return data;
+ }
+
+
+
+void CULoggerServer::DoPostProcessing(TCommand aCmd)
+ {
+ switch(aCmd)
+ {
+ case EStop:
+ Stop();
+ break;
+ case ERestart:
+ RestartOutputting();
+ break;
+ default:
+ break;
+ }
+ }
+
+/**
+This function checks if array of given names contains any of real plugin names (either output of input).
+After call aPluginList will be filtered to contain only proper plugin names (strings that really could be used
+to refer to a real plugin.
+@param aFilter Either EOutputPluginFilter or EInputPluginFilter.
+@param aPluginList Reference to an array which contain list of names that function has to check.
+ */
+void CULoggerServer::FilterPlugins(TPluginFilter aFilter, RArray<TPtrC8>& aPluginList)
+ {
+ TInt errCode = 0;
+ CPlugin::TPluginInterface interfaceId;
+ //assign filter value
+ aFilter==EOutputPluginFilter ? interfaceId=MOutputPlugin::iInterfaceId : interfaceId=MInputPlugin::iInterfaceId;
+
+ //filter plugins
+ TInt i=0;
+ while(i<aPluginList.Count())
+ {
+ CPlugin *plugin = NULL;
+ TRAP(errCode, plugin=CPlugin::NewL(aPluginList[i]));
+ if(plugin && errCode==KErrNone)
+ {
+ TAny *ptr = NULL;
+ TRAP(errCode, ptr=plugin->GetInterfaceL(interfaceId));
+ if(!ptr || errCode!=KErrNone)
+ {
+ aPluginList.Remove(i--);
+ }
+ //cleanup
+ if(plugin)
+ {
+ delete plugin;
+ plugin = NULL;
+ }
+ }
+ ++i;
+ }
+ }
+
+
+
+TBool CULoggerServer::ServerState()
+ {
+ return iBtraceOpen;
+ }
+
+
+TBool CULoggerServer::CheckPluginExists(TPtrC8& aPluginName, TPluginFilter aPluginFilter)
+ {
+ RArray<TPtrC8> pluginsArray;
+ if(aPluginFilter == EOutputPluginFilter)
+ GetInstalledOutputPlugins(pluginsArray);
+ else if(aPluginFilter == EInputPluginFilter)
+ GetInstalledInputPlugins(pluginsArray);
+
+ for(TInt i=0; i<pluginsArray.Count(); ++i)
+ if(aPluginName.Compare(pluginsArray[i])==0)
+ {
+ pluginsArray.Close();
+ return ETrue;
+ }
+
+ pluginsArray.Close();
+ return EFalse;
+ }
+
+
+}//end of namespace
+
+#ifndef __ULOGGER_SERVER_UNIT_TEST
+//Main Entry
+TInt E32Main()
+{
+ return Ulogger::CULoggerServer::StartServer();
+}
+#endif //__ULOGGER_SERVER_UNIT_TEST