/*

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

*

*/

#include "logging.h"

#include "dbgtrcportmgr.h"

#include "ostbaserouter.h"

#include "dbgtrccmdcodes.h"

#include "ostmessage.h"

#include "dbgtrcsrvsession.h"

#include "dbgtrcsrvserver.h"

// Type definitions

// Constants

const TInt KDbgTrcServerTransferBufferExpandSize = 100;

//const TInt KSlot0 = 0;

const TInt KSlot1 = 1;

const TInt KSlot2 = 2;

//const TInt KSlot3 = 3;

// Enumerations

// Classes referenced

// Static functions

//

// Checks for a null'd handle before attempting complete. 

// If handle is null'd then don't complete as this will panic server.

//

void SafeComplete(const RMessagePtr2& aMessage, TInt aCompletionCode)

{

	if(!aMessage.IsNull())

	{

		aMessage.Complete(aCompletionCode);

	}

}

//

// CDbgTrcSrvSession (source)

//

//

// CTrkTcbSrvServer::CDbgTrcSrvSession()

//

// Constructor

//

CDbgTrcSrvSession::CDbgTrcSrvSession(COstBaseRouter* aOstRouter)

: 	iPendingRead(EFalse),

	iPendingWrite(EFalse),

	iPendingReadBufferLength(0),

	iOstRouter(aOstRouter),

	iRecvMessageQueue(1),

	iProtocolIds(1)

{

	LOG_MSG("CDbgTrcSrvSession::CDbgTrcSrvSession");

}

//

// CTrkTcbSrvServer::~CDbgTrcSrvSession()

//

// Destructor

//

CDbgTrcSrvSession::~CDbgTrcSrvSession()

{

	LOG_MSG("CDbgTrcSrvSession::~CDbgTrcSrvSession");

	HandleServerDestruction();

	delete iTransferBuffer;

	iRecvMessageQueue.ResetAndDestroy();

	iRecvMessageQueue.Close();

	iProtocolIds.Reset();

	iProtocolIds.Close();

	//get a reference to the server

	CDbgTrcSrvServer* dbgTrcServer = (CDbgTrcSrvServer*)Server();

	//notify the server that the session has been opened

	if (dbgTrcServer != NULL)

		dbgTrcServer->SessionClosed();

}

//

// CTrkTcbSrvServer::ConstructL()

//

// Creates an instance of CDbgTrcSrvSession.

//

void CDbgTrcSrvSession::ConstructL()

{

	LOG_MSG("CDbgTrcSrvSession::ConstructL");

	iTransferBuffer = CBufFlat::NewL(KDbgTrcServerTransferBufferExpandSize);

	iRecvMessageQueue.Reset();

	iProtocolIds.Reset();

}

void CDbgTrcSrvSession::CreateL()

{

	//get a reference to the server

	CDbgTrcSrvServer* dbgTrcServer = (CDbgTrcSrvServer*)Server();

	//notify the server that the session has been opened

	if (dbgTrcServer != NULL)

		dbgTrcServer->SessionOpened();

}

//

// CTrkTcbSrvServer::NewL()

//

// Static self construction

//

CDbgTrcSrvSession* CDbgTrcSrvSession::NewL(COstBaseRouter* aOstRouter)

{

	LOG_MSG("CDbgTrcSrvSession::NewL");

	CDbgTrcSrvSession* self = new(ELeave) CDbgTrcSrvSession(aOstRouter);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

}

//

// CTrkTcbSrvServer::HandleServerDestruction()

//

// Called by the server's destructor. We need to be told that the server is

// being destroyed.

//

void CDbgTrcSrvSession::HandleServerDestruction()

{

	LOG_MSG("CDbgTrcSrvSession::HandleServerDestruction");

	// disconnect here just in case if the client has not disconnected before shutting down.

	DoDisconnect();

}

//

// CTrkTcbSrvServer::ServiceL()

//

// Services requests from a client.

// Called by the IPC framework whenever a client sends a request to the server.

//

void CDbgTrcSrvSession::ServiceL(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::ServiceL");

	const TInt cmd = aMessage.Function();	

	switch(cmd)

	{

		case EDbgTrcCmdCodeGetAcmConfig:

			CmdGetAcmConfigL(aMessage);

			break;

		case EDbgTrcCmdCodeSetAcmConfig:

			CmdSetAcmConfigL(aMessage);

			break;

		case EDbgTrcCmdCodeOpen:

			CmdOpenCommPortL(aMessage);

			break;

		case EDbgTrcCmdCodeClose:

			CmdCloseCommPort(aMessage);

			break;

		case EDbgTrcCmdCodeRegisterId:

			CmdRegisterProtocol(aMessage);

			break;

		case EDbgTrcCmdCodeRegisterIds:

			CmdRegisterProtocolIdsL(aMessage);

			break;

		case EDbgTrcCmdCodeUnRegisterId:

			CmdUnRegisterProtocol(aMessage);

			break;

		case EDbgTrcCmdCodeUnRegisterIds:

			CmdUnRegisterProtocolIdsL(aMessage);

			break;

		case EDbgTrcCmdCodeReadMsg:

			CmdReadMsgL(aMessage);

			break;

		case EDbgTrcCmdCodeReadCancel:

			CmdReadCancel(aMessage);			

			break;

		case EDbgTrcCmdCodeWriteMsg:

			CmdWriteMsgL(aMessage);

			break;

		case EDbgTrcCmdCodeWriteCancel:

			CmdWriteCancel(aMessage);			

			break;

		case EDbgTrcCmdDisconnect:

			CmdDisconnect(aMessage);

		default:

			aMessage.Panic(KServerIntiatedSessionPanic, EDbgTrcServerInitiatedClientPanicInvalidOperation);

			break;

	}

}

//

// CTrkTcbSrvServer::CmdGetAcmConfigL()

//

// Gets the current port configuration 

//

void CDbgTrcSrvSession::CmdGetAcmConfigL(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdGetAcmConfigL");

	const TInt desLength = static_cast<TInt>(aMessage.Int0());

	if (desLength > 0 && desLength == sizeof(TAcmConfigV01))

	{

		TAcmConfig acmConfig;

		iOstRouter->GetPortConfig(acmConfig);

		aMessage.WriteL(KSlot1, acmConfig);		

		aMessage.Complete(KErrNone);

	} 

	else

	{

		aMessage.Complete(KErrBadDescriptor);		

	}

}

//

// CTrkTcbSrvServer::CmdSetAcmConfigL()

//

// Sets the port configuration if its not already set

//

void CDbgTrcSrvSession::CmdSetAcmConfigL(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdSetAcmConfigL");

	const TInt desLength = static_cast<TInt>(aMessage.Int0());

	if (desLength > 0 && desLength == sizeof(TAcmConfigV01))

	{

		TAcmConfig acmConfig;

		aMessage.ReadL(KSlot1, acmConfig);

		TInt err = iOstRouter->SetPortConfig(acmConfig);		

		aMessage.Complete(err);

	} 

	else

	{

		aMessage.Complete(KErrBadDescriptor);

	}

}

//

// CTrkTcbSrvServer::CmdOpenCommPort()

//

// Opens the comm port, if its already opened, 

// just increments the number of active connects and returns true

//

//

void CDbgTrcSrvSession::CmdOpenCommPortL(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdOpenCommPort");

	TInt err = iOstRouter->OpenCommPortL();

	aMessage.Complete(err);

}

//

// CTrkTcbSrvServer::CmdCloseCommPort()

//

// Closes the comm port, the port is actually closed when the

// number of active connections is 0

//

//

void CDbgTrcSrvSession::CmdCloseCommPort(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdCloseCommPort");

	TInt err = iOstRouter->CloseCommPort();

	aMessage.Complete(err);

}

//

// CTrkTcbSrvServer::CmdRegisterProtocol()

//

// Registers the protocol with the id

// This is necessary to be able to read messages

//

//

void CDbgTrcSrvSession::CmdRegisterProtocol(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdRegisterProtocol");

	const TOstProtIds aProtocolId = static_cast<TOstProtIds>(aMessage.Int0());

	TBool aNeedHeader = static_cast<TBool>(aMessage.Int1());

	iOstRouter->RegisterProtocol(aProtocolId, this, aNeedHeader);

	iProtocolIds.Append(aProtocolId);	

	aMessage.Complete(KErrNone);

}

//

// CTrkTcbSrvServer::CmdUnRegisterProtocol()

//

// Registers the protocol with the id

// This is necessary to be able to read messages

//

//

void CDbgTrcSrvSession::CmdUnRegisterProtocol(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdUnRegisterProtocol");

	const TOstProtIds aProtocolId = static_cast<TOstProtIds>(aMessage.Int0());

	iOstRouter->UnRegisterProtocol(aProtocolId);

	for (TInt i=0; i<iProtocolIds.Count(); i++)

	{

		if (iProtocolIds[i] == aProtocolId)

		{

			iProtocolIds.Remove(i);

			break;

		}

	}

	aMessage.Complete(KErrNone);

}

//

// CTrkTcbSrvServer::CmdRegisterProtocolIds()

//

// Registers the protocol with the id

// This is necessary to be able to read messages

//

//

void CDbgTrcSrvSession::CmdRegisterProtocolIdsL(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdRegisterProtocolIdsL");

	TBool aNeedHeader = static_cast<TBool>(aMessage.Int0());

	const TInt numberOfIds = static_cast<TInt>(aMessage.Int1());

	TBuf8<25> protocolIds;

	aMessage.ReadL(KSlot2, protocolIds);

	const TUint8* protocolPtr = protocolIds.Ptr();

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

	{

		iOstRouter->RegisterProtocol((TOstProtIds)protocolPtr[i], this, aNeedHeader);

		iProtocolIds.Append((TOstProtIds)protocolPtr[i]);

	}

	aMessage.Complete(KErrNone);

}

//

// CTrkTcbSrvServer::CmdUnRegisterProtocol()

//

// Registers the protocol with the id

// This is necessary to be able to read messages

//

//

void CDbgTrcSrvSession::CmdUnRegisterProtocolIdsL(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdUnRegisterProtocolIdsL");

	const TInt numberOfIds = static_cast<TInt>(aMessage.Int0());

	TBuf8<25> protocolIds;

	aMessage.ReadL(KSlot1, protocolIds);

	const TUint8* protocolPtr = protocolIds.Ptr();

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

	{

		iOstRouter->UnRegisterProtocol((TOstProtIds)protocolPtr[i]);

		for (TInt j=0; j<iProtocolIds.Count(); j++)

		{

			if (iProtocolIds[j] == (TOstProtIds)protocolPtr[i])

			{

				iProtocolIds.Remove(j);

				break;

			}

		}

	}

	aMessage.Complete(KErrNone);

}

//

// CTrkTcbSrvServer::CmdReadMsgL()

//

// Gets the data for read file request and calls the session engine read file method.

//

void CDbgTrcSrvSession::CmdReadMsgL(const RMessage2& aMessage)

{		

	LOG_MSG("CDbgTrcSrvSession::CmdReadMsg");

	if (iProtocolIds.Count() <= 0)

	{

		// No protocols are registered, just complete request here.

		aMessage.Complete(KErrAccessDenied);

		return;

	}

	if (iRecvMessageQueue.Count() > 0)

	{

		LOG_MSG("Message found in recieve queue");

		iPendingReadBufferLength = static_cast<TUint>(aMessage.Int0());		

		COstMessage* ostMsg = iRecvMessageQueue[0];				

		HBufC8* msg = ostMsg->iMsgBuffer;

		if (msg->Length() <= iPendingReadBufferLength)

		{

			//write the file data into the client descriptor

			aMessage.WriteL(KSlot1, msg->Des());			

			aMessage.Complete(KErrNone);

			// now remove the message from the queue

			SafeDelete(iRecvMessageQueue[0]);			

			iRecvMessageQueue.Remove(0);

		}

		else

		{

			aMessage.Complete(KErrBadDescriptor);

		}

	}

	else

	{

		if (iPendingRead)

		{			

			aMessage.Complete(KErrAlreadyExists);

		}

		else

		{

			iBlockedRead = aMessage;

			iPendingReadBufferLength = static_cast<TUint>(aMessage.Int0());		

			iPendingRead = ETrue;

			// initiate the read.

			iOstRouter->ReadMessage();

		}

	}

}

void CDbgTrcSrvSession::CmdReadCancel(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdReadCancel");

	if (iPendingRead && iBlockedRead.Handle())

	{

		SafeComplete(iBlockedRead, KErrCancel);

		iPendingRead = EFalse;						

	}

	// now complete the read cancel request.	

	SafeComplete(aMessage, KErrNone);

}

void CDbgTrcSrvSession::CmdWriteMsgL(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdWriteMsg");

	if (iPendingWrite)

	{

		aMessage.Complete(KErrAlreadyExists);

	}

	else

	{

		const TBool hasHeader = static_cast<TInt>(aMessage.Int0());

		const TInt msgLength = static_cast<TInt>(aMessage.Int1());

		if (msgLength > 0)

		{

			if (!hasHeader && iProtocolIds.Count() != 1)

			{

				// For now, if there is no header, then we should have only one protocol id registered by the client.

				// otherwise we don't support writing the message.

				aMessage.Complete(KErrNotSupported);

				return;

			}

			HBufC8* msgData = HBufC8::NewLC(msgLength);

			TPtr8 pMsgData(msgData->Des());

			aMessage.ReadL(KSlot2, pMsgData);

			iBlockedWrite = aMessage;

			iPendingWrite = ETrue;

			if (hasHeader)

				iOstRouter->WriteMessageL(*msgData, this);

			else

				iOstRouter->WriteMessageL(*msgData, this, iProtocolIds[0]);

			//iOstRouter->WriteMessage(*msgData, this);

			CleanupStack::PopAndDestroy(msgData);			

		}

		else

		{

			aMessage.Complete(KErrBadDescriptor);

		}		

	}

}

void CDbgTrcSrvSession::CmdWriteCancel(const RMessage2& aMessage)

{

	LOG_MSG("CDbgTrcSrvSession::CmdWriteCancel");