// 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)	

	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

		{

		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

*/

{	

	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 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.

*/

	{

	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;

	}