// log.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 "log.h"

#ifdef IOSRV_LOGGING

#include "server.h"

#include "clientserver.h"

#ifndef IOSRV_LOGGING_USES_CLOGGER

_LIT(KLogFileName, "c:\\logs\\iosrv.txt");

_LIT8(KNewLine, "\r\n");

#endif

#if !defined(__WINS__) || defined (EKA2)

CIoLog* gLog = NULL;

#endif

CIoLog* CIoLog::NewL(RFs& aFs)

	{

	CIoLog* self = new(ELeave) CIoLog(aFs);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CIoLog::~CIoLog()

	{

#ifdef IOSRV_LOGGING_USES_CLOGGER

	iClogger.Close();

#else

	iFile.Close();

#endif

#if defined(__WINS__) && !defined(EKA2)

	Dll::SetTls(NULL);

#endif

	}

#define CASE_RETURN_LIT(XXX) case XXX: { _LIT(_KLit, #XXX); return &_KLit; }

#define DEFAULT_RETURN_LIT(XXX) default: { _LIT(_KLit, XXX); return &_KLit; }

const TDesC* CIoLog::StringifyError(TInt aError)

	{

	switch (aError)

		{

		CASE_RETURN_LIT(KErrNone);

		CASE_RETURN_LIT(KErrNotFound);

		CASE_RETURN_LIT(KErrGeneral);

		CASE_RETURN_LIT(KErrCancel);

		CASE_RETURN_LIT(KErrNoMemory);

		CASE_RETURN_LIT(KErrNotSupported);

		CASE_RETURN_LIT(KErrArgument);

		CASE_RETURN_LIT(KErrBadHandle);

		CASE_RETURN_LIT(KErrOverflow);

		CASE_RETURN_LIT(KErrUnderflow);

		CASE_RETURN_LIT(KErrAlreadyExists);

		CASE_RETURN_LIT(KErrPathNotFound);

		CASE_RETURN_LIT(KErrDied);

		CASE_RETURN_LIT(KErrInUse);

		CASE_RETURN_LIT(KErrServerTerminated);

		CASE_RETURN_LIT(KErrServerBusy);

		CASE_RETURN_LIT(KErrCompletion);

		CASE_RETURN_LIT(KErrNotReady);

		CASE_RETURN_LIT(KErrUnknown);

		CASE_RETURN_LIT(KErrCorrupt);

		CASE_RETURN_LIT(KErrAccessDenied);

		CASE_RETURN_LIT(KErrLocked);

		CASE_RETURN_LIT(KErrWrite);

		CASE_RETURN_LIT(KErrDisMounted);

		CASE_RETURN_LIT(KErrEof);

		CASE_RETURN_LIT(KErrDiskFull);

		CASE_RETURN_LIT(KErrBadDriver);

		CASE_RETURN_LIT(KErrBadName);

		CASE_RETURN_LIT(KErrCommsLineFail);

		CASE_RETURN_LIT(KErrCommsFrame);

		CASE_RETURN_LIT(KErrCommsOverrun);

		CASE_RETURN_LIT(KErrCommsParity);

		CASE_RETURN_LIT(KErrTimedOut);

		CASE_RETURN_LIT(KErrCouldNotConnect);

		CASE_RETURN_LIT(KErrCouldNotDisconnect);

		CASE_RETURN_LIT(KErrDisconnected);

		CASE_RETURN_LIT(KErrBadLibraryEntryPoint);

		CASE_RETURN_LIT(KErrBadDescriptor);

		CASE_RETURN_LIT(KErrAbort);

		CASE_RETURN_LIT(KErrTooBig);

		CASE_RETURN_LIT(KErrDivideByZero);

		CASE_RETURN_LIT(KErrBadPower);

		CASE_RETURN_LIT(KErrDirFull);

		CASE_RETURN_LIT(KErrHardwareNotAvailable);

#ifdef EKA2

		CASE_RETURN_LIT(KErrPermissionDenied);

#endif

//		CASE_RETURN_LIT(KErrExtensionNotSupported);

//		CASE_RETURN_LIT(KErrCommsBreak);

		DEFAULT_RETURN_LIT("*** ERROR UNKNOWN ***");

		}

	}

const TDesC* CIoLog::StringifyOpcode(TInt aOpCode)

	{

	switch (aOpCode)

		{

		CASE_RETURN_LIT(EIoHandleClose);

		CASE_RETURN_LIT(EIoHandleSetOwner);

		CASE_RETURN_LIT(EIoHandleSetUnderlyingConsole);

		CASE_RETURN_LIT(EIoHandleAttachedToConsole);

		CASE_RETURN_LIT(EIoCreateReader);

		CASE_RETURN_LIT(EIoOpenReaderByThreadId);

		CASE_RETURN_LIT(EIoOpenReaderByExplicitThreadId);

		CASE_RETURN_LIT(EIoDuplicateReader);

		CASE_RETURN_LIT(EIoCreateWriter);

		CASE_RETURN_LIT(EIoOpenWriterByThreadId);

		CASE_RETURN_LIT(EIoOpenWriterByExplicitThreadId);

		CASE_RETURN_LIT(EIoDuplicateWriter);

		CASE_RETURN_LIT(EIoSetReadWriteMode);

		CASE_RETURN_LIT(EIoSetReadMode);

		CASE_RETURN_LIT(EIoSetReaderToForeground);

		CASE_RETURN_LIT(EIoRead);

		CASE_RETURN_LIT(EIoSetLineSeparator);

		CASE_RETURN_LIT(EIoWrite);

		CASE_RETURN_LIT(EIoReadCancel);

		CASE_RETURN_LIT(EIoWriteCancel);

		CASE_RETURN_LIT(EIoIsForegroundReader);

		CASE_RETURN_LIT(EIoConsoleWaitForKey);

		CASE_RETURN_LIT(EIoConsoleWaitForKeyCancel);

		CASE_RETURN_LIT(EIoConsoleCaptureKey);

		CASE_RETURN_LIT(EIoConsoleCancelCaptureKey);

		CASE_RETURN_LIT(EIoConsoleCaptureAllKeys);

		CASE_RETURN_LIT(EIoConsoleCancelCaptureAllKeys);

		CASE_RETURN_LIT(EIoConsoleCursorPos);

		CASE_RETURN_LIT(EIoConsoleSetCursorPosAbs);

		CASE_RETURN_LIT(EIoConsoleSetCursorPosRel);

		CASE_RETURN_LIT(EIoConsoleSetCursorHeight);

		CASE_RETURN_LIT(EIoConsoleSetTitle);

		CASE_RETURN_LIT(EIoConsoleClearScreen);

		CASE_RETURN_LIT(EIoConsoleClearToEndOfLine);

		CASE_RETURN_LIT(EIoConsoleScreenSize);

		CASE_RETURN_LIT(EIoConsoleSetAttributes);

		CASE_RETURN_LIT(EIoEndPointAttachReader);

		CASE_RETURN_LIT(EIoEndPointAttachWriter);

		CASE_RETURN_LIT(EIoEndPointSetForegroundReadHandle);

		CASE_RETURN_LIT(EIoCreatePipe);

		CASE_RETURN_LIT(EIoCreateConsole);

		CASE_RETURN_LIT(EIoOpenConsole);

		CASE_RETURN_LIT(EIoConsoleImplementation);

		CASE_RETURN_LIT(EIoCreateFile);

		CASE_RETURN_LIT(EIoCreateNull);

		CASE_RETURN_LIT(EIoSetObjectName);

		CASE_RETURN_LIT(EIoCreatePersistentConsole);

		CASE_RETURN_LIT(EIoOpenPersistentConsoleByName);

		CASE_RETURN_LIT(EIoPersistentConsoleAttachReadEndPoint);

		CASE_RETURN_LIT(EIoPersistentConsoleAttachWriteEndPoint);

		CASE_RETURN_LIT(EIoPersistentConsoleDetachReadEndPoint);

		CASE_RETURN_LIT(EIoPersistentConsoleDetachWriteEndPoint);

		CASE_RETURN_LIT(EIoPersistentConsoleNotifyReadDetach);

		CASE_RETURN_LIT(EIoPersistentConsoleNotifyWriteDetach);

		CASE_RETURN_LIT(EIoPersistentConsoleCancelNotifyReadDetach);

		CASE_RETURN_LIT(EIoPersistentConsoleCancelNotifyWriteDetach);

		CASE_RETURN_LIT(EIoHandleIsType);

		CASE_RETURN_LIT(EIoHandleGetName);

		CASE_RETURN_LIT(EIoHandleEquals);

		CASE_RETURN_LIT(EIoReadHandleNotifyChange);

		CASE_RETURN_LIT(EIoReadHandleCancelNotifyChange);

		CASE_RETURN_LIT(EIoDuplicateReaderHandleFromThread);

		CASE_RETURN_LIT(EIoDuplicateWriterHandleFromThread);

		DEFAULT_RETURN_LIT("*** OPCODE UNKNOWN ***");

		}

	}

class TOverflowTruncate : public TDes16Overflow

	{

public:

	virtual void Overflow(TDes16&) {}

	};

class RMessageAccess : public RMsg

	{

public:

	TInt Handle() const { return iHandle; }

	};

void CIoLog::StartServiceLC(const RMsg& aMessage)

	{

	CIoLog& self = Self();

	ASSERT(!self.iInServiceL);

	self.iScratchBuf.SetLength(0);

	self.iScratchBuf = ClientNameL(aMessage);

	CleanupStack::PushL(TCleanupItem(EndService, &self));

	TOverflowTruncate overflow;

	self.iScratchBuf.AppendFormat(_L(" requested %S (opcode: %d, message handle: %d)"), &overflow, StringifyOpcode(aMessage.Function()), aMessage.Function(), static_cast<const RMessageAccess&>(aMessage).Handle());

	self.Write(self.iScratchBuf);

	self.iInServiceL = ETrue;

	}

void CIoLog::EndService(TAny* aSelf)

	{

	CIoLog& self = *(static_cast<CIoLog*>(aSelf));

	ASSERT(self.iInServiceL);

	self.Write(KNullDesC);

	self.iInServiceL = EFalse;

	}

void CIoLog::LogCompletion(const RMsg& aMessage, TInt aError)

	{

	TFullName threadName(_L("unknown"));

	TRAP_IGNORE(threadName = ClientNameL(aMessage));

	CIoLog& self = Self();

	self.iScratchBuf.SetLength(0);

	TOverflowTruncate overflow;

	self.iScratchBuf.AppendFormat(_L("Completing %S's request (opcode: %S, message handle: %d) with %S(%d)"), &overflow, &threadName, StringifyOpcode(aMessage.Function()), static_cast<const RMessageAccess&>(aMessage).Handle(), StringifyError(aError), aError);

	self.Write(self.iScratchBuf);

	}

void CIoLog::Write(const TDesC& aData)

	{

	CIoLog& self = Self();

#ifdef IOSRV_LOGGING_USES_CLOGGER

	if (aData.Length() == 0) return; // The trick of writing knulldesc to get a newline is not really appropriate with clogger

	self.iClogger.Log(aData);

#else

	if (self.iFile.SubSessionHandle())

		{

		self.iNarrowBuf.Copy(aData.Left(self.iNarrowBuf.MaxLength() - KNewLine().Length() - 1));

		if (self.iInServiceL)

			{

			self.iNarrowBuf.Insert(0, _L8("\t"));

			}

		self.iNarrowBuf.Append(KNewLine);

		self.iFile.Write(self.iNarrowBuf);

		self.iFile.Flush();

		}

#endif

	}

void CIoLog::Printf(TRefByValue<const TDesC> aFmt, ...)

	{

	TOverflowTruncate overflow;

	VA_LIST list;

	VA_START(list, aFmt);

	CIoLog& self = Self();

	self.iScratchBuf.SetLength(0);

	self.iScratchBuf.AppendFormatList(aFmt, list, &overflow);

	Write(self.iScratchBuf);

	}

CIoLog::CIoLog(RFs& aFs)

	: iFs(aFs)

	{

	}

void CIoLog::ConstructL()

	{

#ifdef IOSRV_LOGGING_USES_CLOGGER

	_LIT(KIoSrvLog, "iosrv");

	User::LeaveIfError(iClogger.Connect(KIoSrvLog));

#else

//	iFs.MkDirAll(KLogFileName);

	/*User::LeaveIfError*/(iFile.Replace(iFs, KLogFileName, EFileWrite));

#endif

#if defined(__WINS__) && !defined(EKA2)

	Dll::SetTls(this);

#else

	gLog = this;

#endif

	Write(KNullDesC);

	Write(_L("New log created"));

	}

CIoLog& CIoLog::Self()

	{

#if defined(__WINS__) && !defined(EKA2)

	return *(static_cast<CIoLog*>(Dll::Tls()));

#else

	return *gLog;

#endif

	}

#endif