// CloggerClient.cpp

// 

// Copyright (c) 2006 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include "clogger.h"

#include "cliserv.h"

#include "SensibleClient_Internals.h"

#include "common.h"

#include <badesca.h>

#include <s32mem.h>

#include <e32property.h>

#define KFlagsMask 0x0FFFFFFF

#define KTestTagEnabled 0x10000000

#define KNoLogMask 0x80000000 // This is the log mask used internally if you call an overload which doesn't specify one

#define iBody (*reinterpret_cast<RCloggerBody*>(&iPimpl))

#ifndef PERFORMANCE_CRITICAL

// declares RClogger* clogger

#define CheckConnected()                                       \

	RClogger _cloggerHandle;                                   \

	RClogger* clogger = &_cloggerHandle;                       \

	GetTls(clogger, ETrue);                                    \

	if (!clogger) return

#define GetTlsOrConnect(aTag)                                  \

	RClogger _cloggerHandle;                                   \

	RClogger* clogger = &_cloggerHandle;                       \

	TInt err;                                                  \

	TBool isHandle = GetTls(clogger, ETrue, &aTag, &err)

#define GetTlsOrNull()                                         \

	RClogger _cloggerHandle;                                   \

	RClogger* clogger = &_cloggerHandle;                       \

	TBool isHandle = GetTls(clogger, EFalse)

TBool RClogger::GetTls(RClogger*& aClogger, TBool aAutoConnect, const TDesC* aTag, TInt* aError)

	{

	TAny* tls = Dll::Tls();

	if ((TUint)tls & 1)

		{

		// Then it's a handle

		aClogger->SetHandle((TInt)((TUint)tls >> 1));

		return ETrue;

		}

	else if (tls)

		{

		// Then it's a pointer

		aClogger = (RClogger*)tls;

		return EFalse;

		}

	else if (aAutoConnect)

		{

		TInt err = aClogger->Connect(aTag ? *aTag : KNullDesC);

		aClogger->iFlags &= ~EUseHeapBuffer; // Don't (by default) use a buffer for static connections because we can't track it without upgrading TLS

		if (err)

			{

			if (aError) *aError = err;

			aClogger = NULL;

			return ETrue;

			}

		__ASSERT_DEBUG((aClogger->Handle() & 0x80000000) == 0, User::Panic(_L("HandleTooBig"), 0));

		err = Dll::SetTls((TAny*) ((aClogger->Handle() << 1) | 1));

		if (err)

			{

			aClogger->Close();

			if (aError) *aError = err;

			aClogger = NULL;

			}

		return ETrue;

		}

	else

		{

		aClogger = NULL;

		return ETrue;

		}

	}

#endif // PERFORMANCE_CRITICAL

NONSHARABLE_CLASS(RCloggerBody) : public RSensibleSessionBody

	{

public:

	RCloggerBody(RClogger& aSession);

	TInt DoCreateSession(const TDesC &aServer, const TVersion &aVersion, TInt aAsyncMessageSlots);

	TInt DoSendReceive(TInt aFunction, const TIpcArgs &aArgs) const;

	void DoSendReceive(TInt aFunction, const TIpcArgs &aArgs, TRequestStatus& aStatus) const;

	void ServerDiedL();

	void DispatchCallbackL(TServerCallback& aCallback, TCallbackParser& aParser);

private:

	friend class RClogger;

	//RClogger& iSession; // No need to store this, we can calculate it from our this pointer since we know we are always embedded in an RClogger

	};

#define iSession (*(RClogger*)((TUint8*)this - _FOFF(RClogger, iPimpl)))

RCloggerBody::RCloggerBody(RClogger& /*aSession*/)

	: RSensibleSessionBody() //, iSession(aSession)

	{}

TInt RCloggerBody::DoCreateSession(const TDesC &aServer, const TVersion &aVersion, TInt aAsyncMessageSlots)

	{

	return iSession.CreateSession(aServer, aVersion, aAsyncMessageSlots);

	}

TInt RCloggerBody::DoSendReceive(TInt aFunction, const TIpcArgs &aArgs) const

	{

	return iSession.SendReceive(aFunction, aArgs);

	}

void RCloggerBody::DoSendReceive(TInt aFunction, const TIpcArgs &aArgs, TRequestStatus& aStatus) const

	{

	iSession.SendReceive(aFunction, aArgs, aStatus);

	}

EXPORT_C RClogger::RClogger()

	: iFlags(0), iEnabled(EAllEnabled), iBuf(), iSequence(0)

	{

	__ASSERT_COMPILE(sizeof(iPimpl) >= sizeof(RCloggerBody));

	__ASSERT_COMPILE(sizeof(RClogger) == 10*4); // This is the size we've published, it CANNOT change

	// Initialise the body using placement new

	new(iPimpl) RCloggerBody(*this);

	}

EXPORT_C RClogger::RClogger(TAny* aTls)

	: iFlags(0), iEnabled(EAllEnabled), iBuf(), iSequence(0)

	{

	// This overload is only ever supposed to be used by the TlsLog inline functions, hence why it's private but still

	// exported.

	new(iPimpl) RCloggerBody(*this);

	SetHandle(reinterpret_cast<TInt>(aTls));

	}

EXPORT_C TInt RClogger::Connect()

	{

	return Connect(KNullDesC);

	}

EXPORT_C TInt RClogger::Connect(const TDesC& aTag)

	{

	iFlags |= EUseHeapBuffer; // Set by default

	TInt err = iBody.Connect(1, EFalse); // Only need 1 slot as we only have one async function (which is hidden within RSensibleSession)

	if (!err)

		{

		err = ShareAuto();

		}

	if (!err)

		{

		TPckg<TUint32> enabledPkg(iEnabled);

		TInt res = SendReceive(ESetTag, TIpcArgs(&aTag, NULL, &enabledPkg));

		if (res >= 0)

			{

			iSequence = res;

			}

		else

			{

			err = res;

			}

		}

	if (err)

		{

		Close();

		}

	return err;

	}

EXPORT_C TInt RClogger::StaticConnect()

	{

	return StaticConnect(KNullDesC);

	}

#ifndef PERFORMANCE_CRITICAL

EXPORT_C TInt RClogger::StaticConnect(const TDesC& aTag)

	{

	GetTlsOrConnect(aTag);

	if (clogger) return KErrNone;

	else return err;

	}

EXPORT_C void RClogger::StaticClose()

	{

	GetTlsOrNull();

	if (clogger)

		{

		clogger->Close();

		if (!isHandle)

			{

			delete clogger;

			}

		Dll::SetTls(NULL);

		Dll::FreeTls();

		}

	}

#endif // PERFORMANCE_CRITICAL

EXPORT_C void RClogger::Log(TRefByValue<const TDesC> aFmt, ...)

	{

	VA_LIST args;

	VA_START(args, aFmt);

	LogList(KNoLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Log(TUint32 aLogMask, TRefByValue<const TDesC> aFmt, ...)

	{

	VA_LIST args;

	VA_START(args, aFmt);

	LogList(aLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Log(TRefByValue<const TDesC8> aFmt, ...)

	{

	VA_LIST args;

	VA_START(args, aFmt);

	LogList(KNoLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Log(TUint32 aLogMask, TRefByValue<const TDesC8> aFmt, ...)

	{

	VA_LIST args;

	VA_START(args, aFmt);

	LogList(aLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Log(const char* aFmt, ...)

	{

	VA_LIST args;

	VA_START(args, aFmt);

	LogList(KNoLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Log(TUint32 aLogMask, const char* aFmt, ...)

	{

	VA_LIST args;

	VA_START(args, aFmt);

	LogList(aLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::LogList(TRefByValue<const TDesC> aFmt, VA_LIST aList)

	{

	LogList(KNoLogMask, aFmt, aList);

	}

EXPORT_C void RClogger::LogList(TUint32 aLogMask, TRefByValue<const TDesC> aFmt, VA_LIST aList)

	{

	if (!Enabled(aLogMask)) return;

	TUint32 tickCount = User::NTickCount();

	TPtrC fmt(aFmt);

	if (iFlags & ETrimTrailingNewlines)

		{

		TInt len = fmt.Length();

		if (len && fmt[len-1] == '\n') fmt.Set(fmt.Left(len-1));

		len = fmt.Length();

		if (len && fmt[len-1] == '\r') fmt.Set(fmt.Left(len-1));

		}

	#define SF_FORMAT fmt

	#define SF_LIST aList

	#define SF_BUF iBuf

	#define SF_ACTION(buf) SendReceive(ELog8, TIpcArgs(&buf, tickCount, aLogMask))

	#define SF_WIDE

	#define SF_STACKONLY (!(iFlags & EUseHeapBuffer))

	#include "SensibleFormat.h"

	//if (!(iFlags&ECacheClientBuffers)) iBuf.Close();

	}

EXPORT_C void RClogger::LogList(TRefByValue<const TDesC8> aFmt, VA_LIST aList)

	{

	LogList(KNoLogMask, aFmt, aList);

	}

EXPORT_C void RClogger::LogList(TUint32 aLogMask, TRefByValue<const TDesC8> aFmt, VA_LIST aList)

	{

	if (!Enabled(aLogMask)) return;

	TUint32 tickCount = User::NTickCount();

	TPtrC8 fmt(aFmt);

	if (iFlags & ETrimTrailingNewlines)

		{

		TInt len = fmt.Length();

		if (len && fmt[len-1] == '\n') fmt.Set(fmt.Left(len-1));

		len = fmt.Length();

		if (len && fmt[len-1] == '\r') fmt.Set(fmt.Left(len-1));

		}

	#define SF_FORMAT fmt

	#define SF_LIST aList

	#define SF_BUF iBuf

	#define SF_ACTION(buf) SendReceive(ELog8, TIpcArgs(&buf, tickCount, aLogMask))

	#define SF_STACKONLY (!(iFlags & EUseHeapBuffer))

	#include "SensibleFormat.h"

	//if (!(iFlags&ECacheClientBuffers)) iBuf.Close();

	}

EXPORT_C void RClogger::LogList(const char* aFmt, VA_LIST aList)

	{

	TPtrC8 ptr((const TUint8*)aFmt);

	LogList(KNoLogMask, ptr, aList);

	}

EXPORT_C void RClogger::LogList(TUint32 aLogMask, const char* aFmt, VA_LIST aList)

	{

	TPtrC8 ptr((const TUint8*)aFmt);

	LogList(aLogMask, ptr, aList);

	}

#ifndef PERFORMANCE_CRITICAL

EXPORT_C void RClogger::Slog(TUint32 aLogMask, TRefByValue<const TDesC> aFmt, ...)

	{

	CheckConnected();

	VA_LIST args;

	VA_START(args, aFmt);

	clogger->LogList(aLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Slog(TUint32 aLogMask, TRefByValue<const TDesC8> aFmt, ...)

	{

	CheckConnected();

	VA_LIST args;

	VA_START(args, aFmt);

	clogger->LogList(aLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Slog(TUint32 aLogMask, const char* aFmt, ...)

	{

	CheckConnected();

	VA_LIST args;

	VA_START(args, aFmt);

	clogger->LogList(aLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Slog(TRefByValue<const TDesC> aFmt, ...)

	{

	CheckConnected();

	VA_LIST args;

	VA_START(args, aFmt);

	clogger->LogList(KNoLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Slog(TRefByValue<const TDesC8> aFmt, ...)

	{

	CheckConnected();

	VA_LIST args;

	VA_START(args, aFmt);

	clogger->LogList(KNoLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::Slog(const char* aFmt, ...)

	{

	CheckConnected();

	VA_LIST args;

	VA_START(args, aFmt);

	clogger->LogList(KNoLogMask, aFmt, args);

	VA_END(args);

	}

EXPORT_C void RClogger::SlogList(TUint32 aLogMask, TRefByValue<const TDesC> aFmt, VA_LIST aList)

	{

	CheckConnected();

	clogger->LogList(aLogMask, aFmt, aList);

	}

EXPORT_C void RClogger::SlogList(TUint32 aLogMask, TRefByValue<const TDesC8> aFmt, VA_LIST aList)

	{

	CheckConnected();

	clogger->LogList(aLogMask, aFmt, aList);

	}

EXPORT_C void RClogger::SlogList(TUint32 aLogMask, const char* aFmt, VA_LIST aList)

	{

	CheckConnected();

	clogger->LogList(aLogMask, aFmt, aList);

	}

EXPORT_C void RClogger::SlogList(TRefByValue<const TDesC> aFmt, VA_LIST aList)

	{

	CheckConnected();

	clogger->LogList(KNoLogMask, aFmt, aList);

	}

EXPORT_C void RClogger::SlogList(TRefByValue<const TDesC8> aFmt, VA_LIST aList)

	{

	CheckConnected();

	clogger->LogList(KNoLogMask, aFmt, aList);

	}

EXPORT_C void RClogger::SlogList(const char* aFmt, VA_LIST aList)

	{

	CheckConnected();

	clogger->LogList(KNoLogMask, aFmt, aList);

	}

EXPORT_C void RClogger::SetStaticLogBehaviour(TUint aLogBehaviour)

	{

	GetTlsOrConnect(KNullDesC);

	if (isHandle && (aLogBehaviour != 0))

		{

		// Then we need to upgrade from handle to pointer

		TInt err = KErrNoMemory;

		RClogger* ptr = new RClogger();

		if (ptr)

			{

			ptr->SetHandle(clogger->Handle());

			err = Dll::SetTls(ptr);

			if (err) delete ptr;

			}

		if (err)

			{

			// Then log it.

			_LIT(KErr, "RClogger couldn't upgrade handle to pointer, err %i");

			clogger->Log(KErr(), err);

			aLogBehaviour = 0; // Don't update flags if we failed to honour them

			}

		else

			{

			clogger = ptr;

			}

		}

	clogger->SetLogBehaviour(aLogBehaviour);

	}

#endif // PERFORMANCE_CRITICAL

EXPORT_C void RClogger::SetLogBehaviour(TUint aLogBehaviour)

	{

	iFlags = (iFlags & ~KFlagsMask) | (aLogBehaviour & KFlagsMask);

	if (!(iFlags & EUseHeapBuffer)) iBuf.Close();

	/* This is not needed any more

	if (iFlags & EMonitorTagState)

		{

		iBody.StartCallbackDispatcher();

		}

	else

		{

		iBody.StopCallbackDispatcher();

		}

	*/

	}

EXPORT_C TInt RClogger::SetEnabled(const TDesC& aTag, TUint32 aEnabledMask)

	{

	return SendReceive(ESetEnabled, TIpcArgs(&aTag, aEnabledMask));

	}

EXPORT_C TUint32 RClogger::IsEnabled(const TDesC& aTag)

	{

	TPckgBuf<TUint32> logMask;

	TInt res = SendReceive(EIsEnabled, TIpcArgs(&aTag, &logMask));

	return res < 0 ? EFalse : logMask();

	}

/*

EXPORT_C void RClogger::TailLogFile(TInt aNumberOfChars)

	{

	SendReceive(ETailLogToRDebug, TIpcArgs(aNumberOfChars));

	}

EXPORT_C void RClogger::TailLogFile(TDes8& aBuf)

	{

	SendReceive(ETailLogToBuf, TIpcArgs(&aBuf));

	}

*/

EXPORT_C void RClogger::SetGlobalOptions(TUint aGlobalOptions)

	{

	SendReceive(ESetGlobalOptions, TIpcArgs(aGlobalOptions));

	}

EXPORT_C TUint RClogger::GetGlobalOptions()

	{

	return SendReceive(EGetGlobalOptions, TIpcArgs());

	}

EXPORT_C TInt RClogger::GetRamBufferSize(TInt* aNumberOfBuffers)

	{

	TBuf8<8> buf;

	buf.SetLength(8);

	SendReceive(EGetRamBufferSize, TIpcArgs(&buf));

	TInt* ptr = (TInt*)buf.Ptr();

	TInt size = ptr[0];

	if (aNumberOfBuffers)

		{

		*aNumberOfBuffers = ptr[1];

		}

	return size;

	}

EXPORT_C void RClogger::SetRamBufferSize(TInt aSize, TInt aNum)

	{

	SendReceive(ESetRamBufferSize, TIpcArgs(aSize, aNum));

	}

EXPORT_C TInt RClogger::Rotate()

	{

	return SendReceive(ERotate, TIpcArgs());