// MiscServer.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 "CloggerServer.h"
#include <fshell/common.mmh>
#include <fshell/ltkutils.h>

#ifdef FSHELL_EZLIB_SUPPORT
#include <EZCompressor.h>
//#include <EZDecompressor.h>
#include <EZlib.h>
#include <EZGzip.h>
#endif

_LIT8(KDiskFull, "\r\n" MINTAGSTART "Log truncated due to disk full\r\n");

void CLogWriter::WriteBuf(TInt aBuf)
	{
	ASSERT(!IsActive() && iEnabled);
		{
		iBuf = aBuf;
		iFile.Write(iServer.GetBuf(aBuf), iStatus);
		SetActive();
		}
	}

TBool CLogWriter::IsBusyWriting()
	{
	return IsActive();
	}

void CLogWriter::RunL()
	{
	if (iStatus == KErrDiskFull)
		{
		//TODO Make this occur before the disk is actually completely empty?
		TInt filePos = 0;
		TInt err = iFile.Seek(ESeekCurrent, filePos);
		if (err == KErrNone && filePos > KDiskFull().Length()) // ensure the file has enough room in it for our message
			{
			// Rewind the log file and overwrite the tail of it with a warning to say the disk is full
			filePos = filePos - KDiskFull().Length();
			err = iFile.Seek(ESeekStart, filePos);
			if (err == KErrNone)
				{
				iFile.Write(KDiskFull, iStatus);
				SetActive();
				return;
				}
			}
		}
	iServer.CompletedWritingBuf(this, iBuf);
	}

void CLogWriter::DoCancel()
	{
	// There's no way to cancel a file write (or any semantic sense to do so) so by doing nothing we get the SyncWaitForCompletion behaviour we wanted
	}

CLogWriter::~CLogWriter()
	{
	// Don't cancel, CloggerServer is supposed to guarantee we won't be deleted when still writing
	//Cancel();
	}

void CLogWriter::CloseWriter()
	{
	delete this;
	}

void CLogWriter::SetEnabled(TBool aEnabled)
	{
	if (!iFile.SubSessionHandle())
		{
		// If the log file is not open, we can't enable ourselves even if the client asks us to
		aEnabled = EFalse;
		}
	iEnabled = aEnabled;
	}

CRDebugWriter::CRDebugWriter(CCloggerServer& aServer)
	: iServer(aServer)
	{}

void CRDebugWriter::WriteBufL(const TDesC8& aBuf)
	{
	TInt maxLen = 256;

	// RDebug::Print only accepts 256 chars on the kernel side, so split the write up
	TInt pos = 0;
	while (pos < aBuf.Length())
		{
		TPtrC8 frag = aBuf.Mid(pos, Min(maxLen, aBuf.Length() - pos));
		//Exec::DebugPrint((TAny*)&frag, 1); // This is quicker than calling RDebugPrint - cuts down on a memory copy
		// ^ Except that you can't do it from non-euser code...
		LtkUtils::RawPrint(frag);
		pos += frag.Length();
		}
	}

void CRDebugWriter::CloseWriter()
	{
	delete this;
	}

///////////////

TInt CSyncWriterWrapper::ThreadFunction(TAny* aSelf)
	{
	CTrapCleanup* cleanup=CTrapCleanup::New();
	if (!cleanup) return KErrNoMemory;
	
	CSyncWriterWrapper* self = static_cast<CSyncWriterWrapper*>(aSelf);
	for (;;)
		{
		User::WaitForRequest(self->iThreadStatus);
		//User::After(1); //DEBUG TO TEST SLOW WRITERS
		if (self->iThreadStatus != KErrNone)
			{
			break;
			}

		const TDesC8& buf = self->iServer.GetBuf(self->iBuf);

		TRAPD(err, self->iWriter.WriteBufL(buf));

		self->iThreadStatus = KRequestPending;
		TRequestStatus* stat = &self->iStatus;
		self->iMainThread.RequestComplete(stat, err);
		}

	delete cleanup;
	return self->iThreadStatus.Int();
	}

void CSyncWriterWrapper::WriteBuf(TInt aBuf)
	{
	ASSERT(!IsActive() && iEnabled);
		{
		iBuf = aBuf;
		iStatus = KRequestPending;
		SetActive();
		TRequestStatus* stat = &iThreadStatus;
		iWorkerThread.RequestComplete(stat, KErrNone);
		}
	}

TBool CSyncWriterWrapper::IsBusyWriting()
	{
	return IsActive();
	}

void CSyncWriterWrapper::RunL()
	{
	iServer.CompletedWritingBuf(this, iBuf);
	}

void CSyncWriterWrapper::DoCancel()
	{
	// There's no way to cancel a sync writer
	}

CSyncWriterWrapper::~CSyncWriterWrapper()
	{
	// Don't cancel, CloggerServer is supposed to guarantee we won't be deleted when still writing
	//Cancel();
	if (iWorkerThread.Handle())
		{
		TRequestStatus* stat = &iThreadStatus;
		iWorkerThread.RequestComplete(stat, KErrCancel);
		TRequestStatus rv;
		iWorkerThread.Rendezvous(rv);
		User::WaitForRequest(rv);
		iWorkerThread.Close();
		}
	iMainThread.Close();
	if (iOwnWriter)
		{
		iWriter.CloseWriter();
		}
	}

void CSyncWriterWrapper::CloseWriter()
	{
	delete this;
	}

void CSyncWriterWrapper::SetEnabled(TBool aEnabled)
	{
	iEnabled = aEnabled;
	}

CSyncWriterWrapper::CSyncWriterWrapper(CCloggerServer& aServer, MSyncWriter& aWriter)
	: CActive(EPriorityHigh), // It's more important to keep writing than to handle clientserver calls
	iServer(aServer), iWriter(aWriter), iBuf(-1), iEnabled(EFalse)
	{
	CActiveScheduler::Add(this);
	}

CSyncWriterWrapper* CSyncWriterWrapper::NewL(CCloggerServer& aServer, MSyncWriter& aWriter, TInt aWriterId)
	{
	CSyncWriterWrapper* self = new(ELeave) CSyncWriterWrapper(aServer, aWriter);
	CleanupStack::PushL(self);
	self->ConstructL(aWriterId);
	CleanupStack::Pop(self);
	self->iOwnWriter = ETrue;
	return self;
	}

void CSyncWriterWrapper::ConstructL(TInt aWriterId)
	{
	User::LeaveIfError(iMainThread.Open(RThread().Id()));
	_LIT(KName, "SyncWriter%i");
	TBuf<16> name;
	name.Format(KName, aWriterId);
	User::LeaveIfError(iWorkerThread.Create(name, &ThreadFunction, 2048, NULL, this));
	if (aWriterId >= 0)
		{
		iWorkerThread.SetPriority(EPriorityMore); // To ensure buffers aren't being filled without us having a chance to empty them
		}
	else
		{
		iWorkerThread.SetPriority(EPriorityMuchLess); // We use the sync writer wrapper around the background compress of rotated log files, and that operation should be low priority
		}
	iWorkerThread.Resume();
	}

//////////

CLogCompressor* CLogCompressor::NewLC(CCloggerServer& aServer)
	{
	CLogCompressor* self = new(ELeave) CLogCompressor(aServer);
	CleanupStack::PushL(self);
	User::LeaveIfError(self->iFs.Connect());
	self->iFs.ShareAuto();
	return self;
	}

CLogCompressor::CLogCompressor(CCloggerServer& aServer)
	: iServer(aServer)
	{
	}

CLogCompressor::~CLogCompressor()
	{
	}

void CLogCompressor::WriteBufL(const TDesC8& /*aBuf*/)
	{
	TDes& filename = iServer.GetFilenameToRotate();

	HBufC* compressedFile = HBufC::NewLC(filename.Length()+3);
	_LIT(KFmt, "%S.gz");
	compressedFile->Des().Format(KFmt, &filename);

	RFile input;

	//_LIT(KInfo,"Compressing file %S to %S\n");
	//console->Printf(KInfo,&inputFile,compressedFile);

	User::LeaveIfError(input.Open(iFs, filename, EFileStream | EFileRead | EFileShareAny));
	CleanupClosePushL(input);

	TRAPD(err, DoGzipL(input, *compressedFile));

	if (err)
		{
		// If the compress failed, delete any fragment (don't care if this fails)
		iFs.Delete(*compressedFile);
		}

	//_LIT(KHoorah,"Hoorah");
	//console->Printf(KHoorah);

	CleanupStack::PopAndDestroy(&input);
	if (err == KErrNone)
		{
		// Don't delete the original unless the compress succeeded!
		err = iFs.Delete(filename);
		}
	if (err == KErrNone)
		{
		// We've sucessfully compressed our file, so update filename to reflect that
		filename = *compressedFile;
		}
	// Don't do anything if the delete fails - the file(s) will be cleaned up when the max number of rotated logs is exceeded
	CleanupStack::PopAndDestroy(compressedFile);
	}

void CLogCompressor::CloseWriter()
	{
	delete this;
	}

void CLogCompressor::DoGzipL(RFile& aInput, const TDesC& aOutput)
	{
#ifdef FSHELL_EZLIB_SUPPORT
	const TInt bufferSize = 0x8000; // 32 KB
	CEZFileToGZip* com = CEZFileToGZip::NewLC(iFs, aOutput, aInput, bufferSize);
	while (com->DeflateL()){/*do nothing*/}
	CleanupStack::PopAndDestroy(com);
#else
	User::Leave(KErrNotSupported);
#endif
	}

////

CMessageQueueWriter* CMessageQueueWriter::NewL()
	{
	CMessageQueueWriter* self = new(ELeave) CMessageQueueWriter;
	TInt err = self->iQ.CreateGlobal(_L("Clogger.LogMessageQueue"), 4);

	if (err)
		{
		DISOWN(self);
		User::Leave(err);
		}
	return self;
	}

void CMessageQueueWriter::WriteBufL(const TDesC8& aBuf)
	{
	TBuf8<128> buf;
	TPtrC8 lineFrag(aBuf);
	while (lineFrag.Length())
		{
		TInt spaceFree = buf.MaxLength() - buf.Length();
		buf.Append(lineFrag.Left(spaceFree));
		TInt err = iQ.Send(buf);
		if (err == KErrOverflow)
			{
			// Drop a frame
			TBuf8<128> buf2;
			iQ.Receive(buf2);
			// And resend
			err = iQ.Send(buf);
			}

		lineFrag.Set(lineFrag.Mid(Min(spaceFree, lineFrag.Length())));
		buf.Zero();
		}
	}

void CMessageQueueWriter::CloseWriter()
	{
	delete this;
	}

CMessageQueueWriter::CMessageQueueWriter()
	{
	}

CMessageQueueWriter::~CMessageQueueWriter()
	{
	iQ.Close();
	}

CDebugRouterClient* CDebugRouterClient::NewL(CCloggerServer& aServer)
	{
	CDebugRouterClient* self = new(ELeave) CDebugRouterClient(aServer);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

void CDebugRouterClient::ConstructL()
	{
	TInt err = RCloggerDebugRouter::LoadDriver();
	if (err != KErrAlreadyExists)
		{
		User::LeaveIfError(err);
		}
	User::LeaveIfError(iDebugRouter.Open());
	}

void CDebugRouterClient::OpenChunkL()
	{
	if (!iSharedChunk.Handle())
		{
		User::LeaveIfError(iDebugRouter.OpenChunk(iSharedChunk));
		iTempBuf.CreateL(2048);
		}
	}

CDebugRouterClient::CDebugRouterClient(CCloggerServer& aServer)
: CActive(CActive::EPriorityStandard + 1), iServer(aServer) // Priority just higher than the server object - it's slightly more important we keep the device driver buffer serviced than we handle normal logging requests
	{
	CActiveScheduler::Add(this);
	}

CDebugRouterClient::~CDebugRouterClient()
	{
	Cancel();
	if (iDebugRouter.Handle())
		{
		iDebugRouter.EnableDebugRouting(RCloggerDebugRouter::EDisable); // I don't really know whether to call this before or after the cancel
		iDebugRouter.Close();
		}
	RCloggerDebugRouter::CloseDriver();
	iSharedChunk.Close();
	iTempBuf.Close();
	}

TPtrC8 Read(TDes8& aTempBuf, TPtrC8& aData, TInt aLength, TPtrC8& aOverflowData)
	{
	if (aLength <= aData.Length())
		{
		// Can read it from this buffer
		TPtrC8 res(aData.Left(aLength));
		aData.Set(aData.Mid(aLength));
		return res;
		}
	else /*if (aLength > aData.Length())*/
		{
		// Descriptor spans wrap point, so need to copy into temp buf
		aTempBuf.Copy(aData.Left(aTempBuf.MaxLength())); // If anyone's crazy enough to write a platsec diagnostic string longer than 2k, it gets truncated
		TInt overflowLen = aLength - aData.Length();
		aData.Set(aOverflowData); // Wrap aData
		aOverflowData.Set(TPtrC8());
		if (overflowLen > aData.Length())
			{
			ASSERT(EFalse); // Shouldn't happen
			// in urel, return everything we've got
			return aData;
			}
		aTempBuf.Append(aData.Left(overflowLen));
		aData.Set(aData.Mid(overflowLen));
		return TPtrC8(aTempBuf);
		}
	}

void CDebugRouterClient::RunL()
	{
	TUint chunkSize = iSharedChunk.Size();
	const TUint KDataStartOffset = sizeof(SDebugChunkHeader);
	SDebugChunkHeader* chunkHeader = (SDebugChunkHeader*)iSharedChunk.Base();
	TUint start = chunkHeader->iStartOffset;
	TUint end = chunkHeader->iEndOffset;
	TUint overflows = chunkHeader->iOverflows;

	TBool wrap = (start > end);
	TUint endLen = wrap ? chunkSize - start : end - start;
	TUint startLen = wrap ? end - KDataStartOffset : 0;

	TPtrC8 endData(iSharedChunk.Base() + start, endLen);
	TPtrC8 startData;
	if (wrap) startData.Set(iSharedChunk.Base() + KDataStartOffset, startLen);
	TPtrC8 data(endData);

	while (data.Length())
		{
		TPtrC8 header = Read(iTempBuf, data, sizeof(SCloggerTraceInfo), startData);
		if (header.Length() < (TInt)sizeof(SCloggerTraceInfo))
			{
			ASSERT(EFalse); // for udeb
			break; // Something's broken
			}
		SCloggerTraceInfo info;
		Mem::Copy(&info, header.Ptr(), sizeof(SCloggerTraceInfo));
		ASSERT(info.iTraceType == 'K' || info.iTraceType == 'U' || info.iTraceType == 'P');
		TPtrC8 msg = Read(iTempBuf, data, info.iLength, startData);
		iServer.LogKernMessage(info.iTraceType, info.iTickCount, info.iThreadId, msg);
		}
	if (overflows)
		{
		_LIT8(KErr, "RDebug::Print buffer overflowed, %u calls not logged");
		iServer.LogError(KErr, overflows);
		}
	// Zero the memory so it's easier to read in the crashlog
	memclr(iSharedChunk.Base() + start, endLen);
	if (startLen) memclr(iSharedChunk.Base() + KDataStartOffset, startLen);
	
	StartRouting(-1); // Magic number to indicate no need to call EnableDebugRouting again
	}

void CDebugRouterClient::DoCancel()
	{
	iDebugRouter.CancelReceive();
	//iDebugRouter.EnableDebugRouting(EFalse);
	// We only call Cancel() outside of our destructor when doing a FlushBuffers, in that case we'd like to make use of the device drivers buffering if possible, and not tell it to stop completely
	}

void CDebugRouterClient::StartRouting(TBool aConsumeLogs)
	{
	if (aConsumeLogs != -1)
		{
		RCloggerDebugRouter::TEnableOption enable = aConsumeLogs ? RCloggerDebugRouter::EEnableRoutingAndConsume : RCloggerDebugRouter::EEnableRouting;
		iDebugRouter.EnableDebugRouting(enable);
		}
	if (!IsActive())
		{
		iDebugRouter.ReceiveData(iStatus);
		SetActive();
		}
	}

void CDebugRouterClient::StopRouting()
	{
	Cancel();
	iDebugRouter.EnableDebugRouting(RCloggerDebugRouter::EDisable);
	}

TInt CDebugRouterClient::RegisterCrashDumpAreas(const TDesC8& aCrashDumpAreas)
	{
	return iDebugRouter.RegisterCrashDumpAreas(aCrashDumpAreas);
	}

TInt CDebugRouterClient::CreateKernChunkForClient(RThread* aClient, TInt aMaxSize, TInt aCommittedSize, RChunk& aOurChunk)
	{
	SCreateChunkParams params;
	params.iHandleOfOtherThread = aClient ? aClient->Handle() : 0;
	params.iMaxSize = aMaxSize;
	params.iCommittedSize = aCommittedSize;
	params.iChunkHandle = 0; // Not strictly necessary to set this
	params.iOtherThreadChunkHandle = 0; // Not strictly necessary to set this
	
	TInt err = iDebugRouter.CreateChunk(params);
	if (err == KErrNone)
		{
		aOurChunk.SetHandle(params.iChunkHandle);
		return aClient ? params.iOtherThreadChunkHandle : KErrNone;
		}
	return err;
	// Return either an error, or the handle for the other thread, or KErrNone if there was no error and we didn't specify another thread
	}

TInt CDebugRouterClient::AdjustChunk(RChunk& aChunk, TInt aNewSize)
	{
	return iDebugRouter.AdjustChunk(aChunk, aNewSize);
	}