// Copyright (c) 2002-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:

 // Main log server engine.

 // Process log requests from multiple clients simultaneously.

 // 

 //

 /**

  @file server.cpp

 */

 #include "server.h"

 CLogServer* CLogServer::NewL()

 /**

  * @return - Instance of the log server

  */

 	{

 	CLogServer * server = new (ELeave) CLogServer();

 	CleanupStack::PushL(server);

 	server->ConstructL();

 	// CServer base class call

 	server->StartL(KFileLogrerServerName);

 	CleanupStack::Pop(server);

 	return server;

 	}

 void CLogServer::ConstructL()

 /**

  * Second phase construction

  */

 	{

 	User::LeaveIfError(Fs().Connect());

 	}

 CLogServer::CLogServer() : CServer2(EPriorityStandard,ESharableSessions)

 /**

  * Constructor

  */

 	{

 	}

 CLogServer::~CLogServer()

 /**

  * Destructor

  */

 	{

 	// Close the array of control structures

 	LogControl().Close();

 	Fs().Close();

 	}

 CSession2* CLogServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const

 /**

  * @param RMessage - RMessage for the session open

  */

 	{

 	// Just create the session

 	CLogSession* session = new (ELeave) CLogSession();

 	return session;

 	}

 void CLogServer::ControlComplete(CLogFileControl& aControl)

 /**

  * @param aControl - Logfile control class reference

  *

  * Checks to see if this control session can be removed 

  */

 	{

 	// Check session count and the data buffers on the queue 

 	if(aControl.SessionCount() || !aControl.QueueEmpty())

 		return;

 	// There are no subsessions mapped to the logfile control class and

 	// no data buffers on its write queue

 	// Loop through the server's control array and remove it then delete it

 	TInt i;

 	for(i=0;i<LogControl().Count();i++)

 		{

 		if(&aControl == LogControl()[i])

 			{

 			// Done

 			LogControl().Remove(i);

 			delete &aControl;

 			break;

 			}

 		}

 	// If it's the last one then exit the server

 	if(!LogControl().Count())

 		CActiveScheduler::Stop();

 	}

 ///////

 CLogSession::CLogSession()

 /**

  * Constructor

  */

 	{

 	}

 CLogSession::~CLogSession()

 /**

  * Destructor

  */

 	{

 	// Check for null

 	// Session close without a createlog call leaves iControl null

 	if(!iControl)

 		return;

 	// A logfile control structure can have multiple server sessions

 	// decrement its server session count

 	iControl->RemoveSession();

 	CLogServer* p=(CLogServer*) Server();

 	// Shuts Down the server if this is the last open session

 	p->ControlComplete(*iControl);

 	}

 void CLogSession::ServiceL(const RMessage2& aMessage)

 /**

  * @param aMessage - Function and data for the session

  */

 	{

 	switch(aMessage.Function())

 		{

 		// API CreateLog() call

 		case RFileFlogger::ECreateLog :

 			{

 			// Sanity check to make sure it's not been called multiple times

 			if(iControl)

 				{

 				aMessage.Complete(KErrInUse);

 				break;

 				}

 			// Get the filepath

 			// size policed on the client side

 			TBuf<KMaxLoggerFilePath> logFilePath;

 			// Read it

 			aMessage.ReadL(0,logFilePath);

 			// Get the log mode in the second argument

 			RFileFlogger::TLogMode logMode;

 			logMode = (RFileFlogger::TLogMode)aMessage.Int1();

 			// Get a pointer to the parent server

 			CLogServer* server=(CLogServer*) Server();

 			// For compare's convert the whole path to lower case

 			logFilePath.LowerCase();

 			// Get rid of leading and trailing spaces.

 			logFilePath.Trim();

 			// Loop the through the server's logfile control class list

 			// to see if there's a match.

 			TInt i;

 			for(i=0;i<server->LogControl().Count();i++)

 				{

 				if(server->LogControl()[i]->LogFile() == logFilePath)

 					// This file's already in open so we don't have to open it

 					break;

 				}

 			TInt err = KErrNone;

 			// Check the count

 			if(i < server->LogControl().Count())

 				// Map this session to an existing logfile control class in the list

 				iControl = server->LogControl()[i];

 			else

 				{

 				// Create a new logfile control class

 				// creates/opens the logfile

 				TRAP(err,iControl = CLogFileControl::NewL(*server,logFilePath,logMode));

 				if(!err)

 					{  // nancy

 					// find out the type of output format and assign to this new created control

 					TInt error = logFilePath.Find(_L(".xml"));

 					if(error==KErrNotFound) iControl->SetLogType(CLogFileControl::ETxt);

 					else iControl->SetLogType(CLogFileControl::EXml);					

 					// end nancy

 					// Append it to the logfile control class list

 					server->LogControl().Append(iControl);					

 					}

 				}

 			if(!err)

 				// Increment its session count

 				iControl->AddSession();

 			aMessage.Complete(err);

 			}

 			break;

 		// One of the API write calls

 		case RFileFlogger::EWriteLog :

 			{

 			// Sanity check

 			if(!iControl)

 				{

 				aMessage.Complete(KErrNotFound);

 				break;

 				}

 			// Data can be any size

 			// Get the length from second argument

 			TInt bufferLength = aMessage.Int1();

 			// Get a heap buffer of the right size

 			HBufC8* buffer = HBufC8::NewLC(bufferLength);

 			TPtr8 ptr(buffer->Des());

 			// read the data

 			aMessage.ReadL(0,ptr);			

 			// Get a buffer control class contructed with the heap data

 			// takes ownership

 			CLogBuffer* logBuffer = new (ELeave) CLogBuffer(*buffer);

 			CleanupStack::Pop(buffer);

 			// Add it to the logfile control class buffer queue

 			iControl->AddLogBuffer(*logBuffer);

 			if(!iControl->IsActive())

 				// AO is idle, kick into life

 				iControl->Kick();

 			aMessage.Complete(KErrNone);

 			}

 			break;

 		default:

 			break;

 		}

 	}

 ///////

 CLogFileControl* CLogFileControl::NewL(CLogServer& aParent, const TDesC& aLogFilePath,RFileFlogger::TLogMode aMode)

 /**

  * @param aParent - Server reference for callback

  * @param aLogFilePath - Full path and filename of the logfile

  * @param aMode - Overwrite or Append

  *

  * First phase construction for logfile control class

  */

 	{

 	CLogFileControl* self = new (ELeave) CLogFileControl(aParent,aLogFilePath);

 	CleanupStack::PushL(self);

 	self->ConstructL(aMode);

 	CleanupStack::Pop();

 	return self;

 	}

 CLogFileControl::CLogFileControl(CLogServer& aParent,const TDesC& aLogFilePath) :

 	iParent(aParent),

 	iLogFileName(aLogFilePath),

 	iTransmitted(EFalse)

 /**

  * @param aParent - Server reference for callback

  * @param aLogFilePath - Full path and filename of the logfile

  *

  * Constructor - Safe initialisation

  */

 	{

 	iQueue.SetOffset(CLogBuffer::LinkOffset());

 	}

 void CLogFileControl::ConstructL(RFileFlogger::TLogMode aMode)

 /**

  * @param aMode - Overwrite or Append

  *

  * Second phase construction - Create or open the logfile

  */

 	{

 	if(aMode == RFileFlogger::ELogModeOverWrite)

 		// In overwrite mode replace

 		User::LeaveIfError(iLogFile.Replace(iParent.Fs(),iLogFileName,EFileWrite));

 	else

 		{

 		// For append try open then replace

 		TInt err = iLogFile.Open(iParent.Fs(),iLogFileName,EFileWrite);

 		if(err != KErrNone)

 			// Bomb out if replace fails

 			User::LeaveIfError(iLogFile.Replace(iParent.Fs(),iLogFileName,EFileWrite));

 		else

 			{

 			// Open worked. Position at EOF

 			TInt pos;

 			iLogFile.Size(pos);

 			User::LeaveIfError(iLogFile.Seek(ESeekEnd,pos));

 			}

 		}

 	}

 CLogFileControl::~CLogFileControl()

 /**

  * Destructor

  * The server maintains a list of these classes and will not destruct one if there

  * is data on its queue

  * Destructor just closes the file handle.

  */

 	{

 	iLogFile.Close();

 	}

 void CLogFileControl::RunL()

 /**

  * Main File writing pump

  * Called on write completion or Kick() by the session that accepts the data

  */

 	{

 #if (defined _DEBUG)

 	_LIT(KPanic,"LogEng RunL()");

 #endif

 	__ASSERT_DEBUG(iStatus.Int() == KErrNone,User::Panic(KPanic,iStatus.Int()));

 	// Check to see if this is the result of write completion

 	if(iTransmitted)

 		{

 		// Write completed

 		// Remove the buffer at the head of the queue and free it

 		CLogBuffer* buffer = iQueue.First();

 		iQueue.Remove(*buffer);

 		delete buffer;

 		}

 	// Check to see if there's more on the queue

 	if(!iQueue.IsEmpty())

 		{

 		// There is so write the head of the queue

 		CLogBuffer* buffer = iQueue.First();	

 		SetActive();

 		// Set the flag to say we've transmitted

 		iTransmitted = ETrue;

 //  ------------------------------------

 		if(iLogFormat==ETxt)  WriteTxt(buffer->Buf());

 		else WriteXml(buffer->Buf());

 		} 

 	else

 		{

 		// Nothing on the queue

 		iTransmitted = EFalse;

 		// Call into the server to check if this resource can be freed

 		iParent.ControlComplete(*this);

 		}

 	}

 void CLogFileControl::WriteXml(const TDesC8 &aDes)

 /**

  * @param aDes - send a aDes string in xml format to a log file

  */

 	{

 /*--------- Maintaince Warning:  -----------------------------------

 ******* the fomat of below is sensible from client original format.  

 ******* Any change should match actual string formated from client. 

 ******* Double check the code on client side 

 * The current assumtion of format:

 * First string values are seperated by sign " - " and extra pair of fields are

 * seperated from main log message  by long unusual string "LogFieldsRequiredBeingAddedToAboveLogMessage"

 * The \t used to seperate field name and field value and \r\n used to seperate

 * each other from those pairs of field

 * \t\t\t\t\t\t is used to end of whole string

 --------------------------------------------------------------------------------*/

 		_LIT8(KxmlHeader,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\r\n<LOGFILE>");

 		//The order of variables:

 		// time 		- aTime

 		// Severity 	- aSeverity

 		// Thread 		- aThread

 		// Filename 	- aFilename

 		// Linenumber 	- aLinenumber

 		// Text 		- aText

 		// Start of string retrive/deformating 

 		HBufC8* pBuf1 = HBufC8::New(KMaxLoggerLineLength*2); //(aDes.Length()+200);

 		if(!pBuf1)

 			{

 			return; // no memory 

 			}

 		TPtr8 aPtr(pBuf1->Des());  // used for searching

 		TPtr8 alogbuf(pBuf1->Des());  //used for final log

 		aPtr.Append(aDes);

 		TPtrC8 SearchBuf;

 		TInt aCount[8]; 

 		aCount[0]=0;

 		TInt posI(0);

         // retrive log message:

 		// Retrive common part of log message:

 		TInt i=0;

 		for(i=1; i<6; i++)

 			{

 			SearchBuf.Set(aPtr.Mid(posI));

 			aCount[i]=SearchBuf.Find(KSeperation8)+posI;

 			posI=aCount[i]+3;

 			if(aCount[i]<aCount[i-1])	

                 {

                 delete pBuf1;

                 return; // wrong format string from client

                 }

 			}

 		// seperating common log message and extra log fields will be easy for future maintaince.

 		TLogField8* alogField = new TLogField8[6];  // the common part of log message for both 

 								  					// with and without extra log fields

 		if(!alogField) 

             {

             delete pBuf1;

             return; // no memory

             }

 		TLogField8* extralogField=NULL; // only applied to extra log fields

 		TInt alength=0;  // a length of array of extra log fields

 		alogField[0].iLogTag8.Copy(_L8("TIME"));

 		alogField[1].iLogTag8.Copy(_L8("SEVERITY"));

 		alogField[2].iLogTag8.Copy(_L8("THREAD"));

 		alogField[3].iLogTag8.Copy(_L8("FILENAME"));

 		alogField[4].iLogTag8.Copy(_L8("LINENUMBER"));

 		alogField[5].iLogTag8.Copy(_L8("TEXT"));

 		alogField[0].iLogValue8.Copy(aPtr.Mid(aCount[0],aCount[1]-aCount[0]));

 		for(i=1; i<5; i++)

 			{

 			alogField[i].iLogValue8.Copy(aPtr.Mid(aCount[i]+3,aCount[i+1]-aCount[i]-3));				

 			}

 		SearchBuf.Set(aPtr.Mid(posI));

 		aCount[6]=SearchBuf.Find(_L8("LogFieldsRequiredBeingAddedToAboveLogMessage"))+posI; 

 		if(aCount[6]<posI)  // no addtional fields. Find return value is KErrNotFound or >0

 			{

 			alogField[5].iLogValue8.Copy(aPtr.Mid(aCount[5]+3,aDes.Length()-aCount[5]-5));

 			}

 		else

             {

 			alogField[5].iLogValue8.Copy(aPtr.Mid(aCount[5]+3,aCount[6]-aCount[5]-5));

 			posI=aCount[6]+45;  //45 is from the length of long string and a tab

 			SearchBuf.Set(aPtr.Mid(posI));

 			aCount[7]=SearchBuf.Find(_L8("\r\n"))+posI;

 			TLex8 lex(aPtr.Mid(posI,aCount[7]-posI));  // get the length

 			TInt err=lex.Val(alength); 

 			if (err)

                 alength=0; // ignor the extra log fields. Let the log go

 			// Retrive the extra log fields

 			extralogField = new TLogField8[alength];

 			if(!extralogField)

                 {

                 delete pBuf1; 

                 return; // no memory

                 }

 			for(TInt i=0; i<alength; i++)

 				{

 				aCount[6]=aCount[7]+2;

 				SearchBuf.Set(aPtr.Mid(aCount[6]));

 				aCount[7]=SearchBuf.Find(_L8("\t"))+aCount[6];

 				extralogField[i].iLogTag8.Copy(aPtr.Mid(aCount[6],aCount[7]-aCount[6]));

 				aCount[6]=aCount[7]+1;

 				SearchBuf.Set(aPtr.Mid(aCount[6]));

 				aCount[7]=SearchBuf.Find(_L8("\r\n"))+aCount[6];

 				extralogField[i].iLogValue8.Copy(aPtr.Mid(aCount[6],aCount[7]-aCount[6]));

 				}

             }

 		// Start to organize an XML format:

 		TInt afileSize;

 		_LIT(KLogMutex, "LoggingServerMutex");

 		RMutex mutex;

 		TInt r = mutex.CreateGlobal(KLogMutex);

 		if(r==KErrAlreadyExists)

 			r = mutex.OpenGlobal(KLogMutex);  

 		if(!r)

             mutex.Wait(); // If still failed, let logging go without bother the mutex.

 		iLogFile.Size(afileSize);

 		if(afileSize<12) // 12 is from charters of "\r\n</LOGFILE>" 

 					//It shoud happened once at the beginning of the file

 					// such as overwrite mode

             {

 			afileSize=12; // used for lock position

 			alogbuf.Copy(KxmlHeader);

 			}

 		alogbuf.Append(_L8("\r\n<MESSAGE>\r\n"));

 		for(TInt i=0; i<6; i++)

 			{

 			alogbuf.Append(_L8("  <"));

 			alogbuf.Append(alogField[i].iLogTag8);

 			alogbuf.Append(_L8(">"));

 			alogbuf.Append(alogField[i].iLogValue8);

 			alogbuf.Append(_L8("</"));

 			alogbuf.Append(alogField[i].iLogTag8);

 			alogbuf.Append(_L8(">\r\n"));				

 			}

 		for(TInt i=0; i<alength; i++)  

 			{

 			alogbuf.Append(_L8("  <"));

 			alogbuf.Append(extralogField[i].iLogTag8);

 			alogbuf.Append(_L8(">"));

 			alogbuf.Append(extralogField[i].iLogValue8);

 			alogbuf.Append(_L8("</"));

 			alogbuf.Append(extralogField[i].iLogTag8);

 			alogbuf.Append(_L8(">\r\n"));				

 			}

 		alogbuf.Append(_L8("</MESSAGE>"));

 		alogbuf.Append(_L8("\r\n</LOGFILE>"));

 		iLogFile.Write(afileSize-12, alogbuf,iStatus);

 		if(!r)	

 			{

 			mutex.Signal();

 			mutex.Close();				

 			} 

 		if(extralogField)

             delete[] extralogField;

 		delete[] alogField;	

 		delete pBuf1;

 	}

 void CLogFileControl::WriteTxt(const TDesC8 &aDes)

 /**

  * @param aDes - send a aDes string in xml format to a log file

  */

 	{

 /*--------- Maintaince Warning for aLogBuffer -----------------------------------

 ******* the fomat of below is sensible from client original format.  

 ******* Any change should match actual string formated from client. 

 ******* Double check the code on client side 

 * The current assumtion of format:

 * First string values are seperated by sign " - " and extra pair of fields are

 * seperated from main log message  by long unusual string "LogFieldsRequiredBeingAddedToAboveLogMessage"

 * The \t used to seperate field name and field value and \r\n used to seperate

 * each other from those pairs of field

 --------------------------------------------------------------------------------*/

 	iLogFile.Write(aDes,iStatus);

 	}

 ///////

 CLogBuffer::CLogBuffer(HBufC8& aLogBuffer) : iLogBuffer(aLogBuffer)

 /**

  * @param aLogBuffer - Heap descriptor. This class takes ownership

  * Constructor

  */

 	{

 	}

 CLogBuffer::~CLogBuffer()

 /**

  * Destructor

  * This class owns a heap buffer so just free it

  */

 	{

 	delete &iLogBuffer;

 	}