// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// e32test\debyg\LogToFile.cpp

// t_logtofile.exe tests (alongside with d_logtofile.ldd) trace handler hook (TTraceHandler).

// Usage:

// 1. start t_logtofile -p=Pattern

// - Starts logging into memory.(RDebug::Pring, NKern::Print & PletSec log are all considered).

// - Only logs that start with "Pattern" will be logged (case sensitive).Leave '-p=' empty to log them all.

// - All debug loggings to serial port (or epocwnd.out on emulator) are suppressed.

// - There are 64KB memory available for the log. Once the memory is full, the logging stops.

// 2. start t_logtofile stop

// - Stops the logging (unless already stopped due to full memory).

// - Transfers collected logs into c:\logtofile.dat

// The format of the file is as follows:

// The pattern:		Pattern

// Buffer Size is:		65536

// Fast counter freq:	3579545

// 93559955	U	MsgSent

// 108774945	K	Thread t_suser.EXE::Main created @ 0x973fe8 - Win32 Thread ID 0xbbc

// 108810756	U	RTEST TITLE: T_SUSER 2.00(1013)

// The first column is the current value of the fast counter.

// The second column indicates U - user side, K - kernel or P-PlatSec logging.

// 

//

#include <e32debug.h>

#include <e32cons.h>

#include <f32file.h>

#include <e32base.h>

#include <e32base_private.h>

#include "d_logtofile.h"

// The name of the output file use to save the sample data

_LIT(KFileName,"C:\\LogToFile.DAT");

_LIT(KAppName,"Logtofile");

const TInt KHeapSize=0x2000;

#define KPatternMaxSize 10

TBuf8<KPatternMaxSize> Pattern;

/**Server*/

class CLogToFileServer : public CServer2

	{

public:

	static CLogToFileServer* New(TInt aPriority) {return new CLogToFileServer(aPriority);}

private:

	CLogToFileServer(TInt aPriority) : CServer2(aPriority){}

	CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

public:

static RLogToFileDevice iDevice;

static TChunkCreateStr iChunkStr;

static RChunk Chunk;

	};

/**Session*/

class CLogToFileSession : public CSession2

	{

public:

	enum TState {EStart, EStop};

private:

	void ServiceL(const RMessage2& aMessage);

	TInt Stop();

	TInt Start();

	};

/*Client-side session*/

class RLogToFileSession : private RSessionBase

	{

public:

public:

	static inline TInt Start(){return Control(CLogToFileSession::EStart);}

	static inline TInt Stop() {return Control(CLogToFileSession::EStop);}

private:

	static inline TInt Control(CLogToFileSession::TState aRequest);

	};

//------------globals---------------------

RLogToFileDevice CLogToFileServer::iDevice;

TChunkCreateStr  CLogToFileServer::iChunkStr;

RChunk           CLogToFileServer::Chunk;

/**Creates a new client for this server.*/

CSession2* CLogToFileServer::NewSessionL(const TVersion&, const RMessage2&) const

	{

	return new(ELeave) CLogToFileSession();

	}

/**Entry point of the session request*/

void CLogToFileSession::ServiceL(const RMessage2& aMessage)

	{

	TInt r=KErrNone;

	switch (aMessage.Function())

		{

	case EStart:

		{

		r = Start();

		break;

		}

	case EStop:

		{

		r = Stop();

		CActiveScheduler::Stop();//This will stop the server thread.

		break;

		}

	default:

		r=KErrNotSupported;

		}

	aMessage.Complete(r);

	}

/**

This will:

 - Load t_logtofile.ldd

 - Tell ldd to create the chunk

 - Tell ldd to start logging

*/

TInt CLogToFileSession::Start()

	{

	TInt r = User::LoadLogicalDevice(KLogToFileName);

	if(r !=KErrNone && r!=KErrAlreadyExists)

		return r;

	if((r = CLogToFileServer::iDevice.Open())!=KErrNone)	

		{

		User::FreeLogicalDevice(KLogToFileName);

		return r;

		}

	CLogToFileServer::iChunkStr.iSize = 0x10000; //64K chunk size - hard coded

	if((r=CLogToFileServer::iDevice.CreateChunk(&CLogToFileServer::iChunkStr))<0)

	{

		User::FreeLogicalDevice(KLogToFileName);

		return r;

	}

	CLogToFileServer::Chunk.SetHandle(r);

	CLogToFileServer::iDevice.Start();	

	return KErrNone;

}

/**

This will:

 - Tell ldd to stop logging

 - Put the content of the chunk into c:\logtofile.dat

 - Tell ldd to close the chunk

 - Unload t_logtofile.ldd

*/

TInt CLogToFileSession::Stop()

{

	TInt bytes = CLogToFileServer::iDevice.Stop();	

	RFs fs;

	RFile file;

	TInt r;

	TRequestStatus status;

	if(KErrNone != (r = fs.Connect()))

		return r;

	if(KErrNone != (r = file.Replace(fs, KFileName,EFileWrite)))

		{

		fs.Close();

		return r;

		}

	TPtrC8 log(CLogToFileServer::Chunk.Base(),bytes);

	file.Write(log,status);

	User::WaitForRequest(status);

	r = status.Int();

	file.Close();

	fs.Close();

	CLogToFileServer::Chunk.Close();

	CLogToFileServer::iDevice.RemoveChunk();	

	User::FreeLogicalDevice(KLogToFileName);

	return r;

}

/**Sends request to the server*/

TInt RLogToFileSession::Control(CLogToFileSession::TState aRequest)

	{

	RLogToFileSession p;

	TInt r = p.CreateSession(KAppName, TVersion(), 0);

	if (r == KErrNone)

		p.SendReceive(aRequest);

	return r;

	}

/**The entry point for the server thread.*/

LOCAL_C TInt serverThreadEntryPoint(TAny*)

	{

	TInt r=0;

	CLogToFileServer* pS=0;

	CActiveScheduler *pR=new CActiveScheduler;

	if (!pR) User::Panic(_L("Create ActSchdlr error"), KErrNoMemory);

	CActiveScheduler::Install(pR);

	pS=CLogToFileServer::New(0);

	if (!pS)

	{

		delete pR;

		User::Panic(_L("Create svr error"), KErrNoMemory);

	}

	r=pS->Start(KAppName);

	if(r)

		{

		delete pS;

		delete pR;

		User::Panic(_L("Start svr error"), r);

		}

	RThread::Rendezvous(KErrNone);

	CActiveScheduler::Start();

	delete pS;

	delete pR;

	return(KErrNone);

	}

/**Reads the command line and set the matching pattern to be - what is after '-p='*/

void SetPattern(void)

	{

	_LIT8(KPattern,"-p=");

	TBuf<64> c;

	User::CommandLine(c);

	#if defined(_UNICODE)

	TPtr8 ptr = c.Collapse();

	#else

	TPtr8 ptr(c.Ptr(),c.Length(),c.MaxLEngth());

	#endif

	TInt patternStart = ptr.FindF(KPattern);

	if (patternStart < 0)

		{

		Pattern.SetLength(0);

		return;

		}

	patternStart+=3;

	TPtrC8 pattern (ptr.Ptr()+patternStart,Min(ptr.Length()-patternStart, KPatternMaxSize) );

	CLogToFileServer::iChunkStr.iPattern.Copy(pattern);

	}

/**The main program if we have to start logging

   It creates the server and sends start-logging request.*/

void MainL()

	{

	RThread server;

	TRequestStatus status;

	TInt r = 0;

	SetPattern();

	r=server.Create(_L("LogToFileServer"),serverThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,NULL);

	User::LeaveIfError(r);

	server.Resume();

	server.Rendezvous(status);

	User::WaitForRequest(status);

	User::LeaveIfError(status.Int());

	User::LeaveIfError(RLogToFileSession::Start());

	server.Logon(status);

	User::WaitForRequest(status);

	}

/**Returns true if 'stop' is found in the command line*/

TBool GetStop()

	{

	_LIT(KStop,"stop");

	TBuf<64> c;

	User::CommandLine(c);

	if (c.FindF(KStop) >= 0)

		return ETrue;

	return EFalse;

	}

/**LogToFile.exe entry point*/

TInt E32Main()

	{

	if (GetStop())

		return RLogToFileSession::Stop();

	CTrapCleanup::New();

	TRAPD(r,MainL());

	return r;

	}