// 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 "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:

//

/**

 @file

 @internalTechnology

*/

#include <cflog.h>

#include <e32hashtab.h>

#include <ecom/ecom.h>

#include <elements/interfacetable.h>

#include "../inc/cftransportmsg.h"

#include "../inc/cfhookinternals.h"

#include <elements/metatype.h>

#include <cfutil.h>

#include <elements/nm_signals.h>

#include <elements/nm_log.h>

#include <elements/nm_address_internal.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ElemComsFwCfTrnC, "ElemComsFwCfTrnC");

#endif

using namespace CommsFW;

using namespace Messages;

using NetInterfaces::TInterfaceControl;

using Meta::CMetaDataVirtualCtorInPlace;

using Meta::SMetaData;

#ifdef SYMBIAN_TRACE_ENABLE

	_LIT8(KLogTransportSubTag, "cftransport");

#endif

class MMessageDispatcher

	{

public:

	/** Dispatch a received message from the chipper to its destination

	*/

	virtual void DispatchLegacyL(TCFMessage& aMessage, TWorkerId aSenderId, TInt aFirstDispatchLeaveReason) = 0;

	virtual void DispatchInterfaceL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient, const TDesC8& aMessage, TInt aFirstDispatchLeaveReason) = 0;

	};

EXPORT_C void CommsFW::Panic(TCFTransportPanics aReason)

	{

	User::Panic(KCFTransportPanic, aReason);

	}

EXPORT_C void TWorkerThreadDataBase::Init(TWorkerId aWorkerId, TBool aHoldingReference)

	{

	iWorkerId = aWorkerId;

	iThreadId = RThread().Id();

	iHeap = &User::Heap();

	iHoldingReference = aHoldingReference;

	if(iHoldingReference)

		{

		VERIFY_RESULT(iThread.Open(iThreadId, EOwnerProcess), KErrNone);

		iHeap->Open();

		}

	}

EXPORT_C void TWorkerThreadDataBase::Clear()

	{

	iWorkerId = KInvalidWorkerId;

	iThreadId = KNullThreadId;

	if(iHoldingReference)

		{

		iThread.Close();

		iHeap->Close();

		}

	iHeap = NULL;

	}

//

const TInt KReassemblyStoreSize = KMaxNumChips * TCFMessage::KMaxRawBlockSize;

// Handling received chips

class TChipReceiver

	{

public:

	TChipReceiver(MMessageDispatcher& aDispatcher, TWorkerId aPeerId);

	TCFMessage& NextChipStore()

		{

		return reinterpret_cast<TCFMessage&>(*const_cast<TUint8*>(iNextChipStore.Ptr()));

		}

	void ProcessChipL(TInt aFirstDispatchLeaveReason);

	TWorkerId ReceiverWorkerId() const

		{

		return iPeerId;

		}

	TInt ChipsRemaining() const {

		return iChipsRemaining;

	}

private:

	void ResetNextChipStore()

		{

		iNextChipStore.Set(const_cast<TUint8*>(iReassemblyStore.Ptr()), iReassemblyStore.MaxLength(), iReassemblyStore.MaxLength());	//@TODO-TG surely a nicer way?

		}

private:

	MMessageDispatcher& iDispatcher;

	TWorkerId iPeerId;

	TInt iChipsRemaining;

	TPtr8 iNextChipStore;

	TBuf8<KReassemblyStoreSize> iReassemblyStore;

	};

TChipReceiver::TChipReceiver(MMessageDispatcher& aDispatcher, TWorkerId aPeerId)

: iDispatcher(aDispatcher),

  iPeerId(aPeerId),

  iChipsRemaining(0),

  iNextChipStore(NULL, 0)	// initialised properly below

	{

	ResetNextChipStore();

	}

void TChipReceiver::ProcessChipL(TInt aFirstDispatchLeaveReason)

	{

	TCFMessage& chip = NextChipStore();

	if(iChipsRemaining == 0)

		{

		//Not currently in a chipped message, so address is valid

		if (TCFLegacyMessagePacker::IsLegacy(chip))

			{

			//Legacy TCFMessage

			iDispatcher.DispatchLegacyL(chip, iPeerId, aFirstDispatchLeaveReason);

			return;

			}

		if(TCFMessage2::ChipsFollowing(chip) == 0)

			{

			//New TCFMessage2, not chipped

			TRuntimeCtxId* postedFrom;

			TRuntimeCtxId* postedTo;;

			TUint8 offset = static_cast<TCFMessage2&>(chip).ParseGetOffset(postedFrom, postedTo);

			TPtrC8 message(chip.RawBlock() + offset, sizeof(TCFMessage2) - offset);

			iDispatcher.DispatchInterfaceL(*postedFrom, *postedTo, message, aFirstDispatchLeaveReason);

			return;

			}

		//New TCFMessage2, chipped

		iChipsRemaining = TCFMessage2::ChipsFollowing(chip) + 1;

		}

	__ASSERT_DEBUG(iChipsRemaining > 0, User::Panic(KSpecAssert_ElemComsFwCfTrnC, 1));	// single-chip messages all handled above

	if(iChipsRemaining > 1)

		{

		iNextChipStore.Set(iNextChipStore.MidTPtr(TCFMessage::KMaxRawBlockSize));

		}

	else

		{

		TCFMessage2& firstChip = *reinterpret_cast<TCFMessage2*>(const_cast<TUint8*>(iReassemblyStore.Ptr()));

		TRuntimeCtxId* postedFrom;

		TRuntimeCtxId* postedTo;;

		TUint8* msgPtr = firstChip.RawBlock() + firstChip.ParseGetOffset(postedFrom, postedTo);

		TPtrC8 message(msgPtr, iNextChipStore.Ptr() + TCFMessage::KMaxRawBlockSize - msgPtr);

		iDispatcher.DispatchInterfaceL(*postedFrom, *postedTo, message, aFirstDispatchLeaveReason);

		// Only once dispatch hasn't left is it proper to reset for the next message

		ResetNextChipStore();

		}

	// Decrement the remaining chip count only once past the possibility of leaving, so that the state is intact for a post-leave redispatch

	--iChipsRemaining;

	}

void MCommsTransportSender::PostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const Meta::SMetaData& aMessage)

	{

	TUint8 buf[CommsFW::KMaxInlineMessageSize];

	TPtr8 args(buf, sizeof(buf));

	TInt err = aMessage.Store(args);

	__ASSERT_ALWAYS(err == KErrNone, User::Panic(KCFChannelPanic, ECFChanMsgTooBig));	// Metadata too big or corrupt

#ifdef SYMBIAN_TRACE_ENABLE

	// Note: this log output is used by SVG tools - careful when changing it

	NM_LOG_START_BLOCK(KLogTransportSubTag, _L8("Post"));

	NM_LOG_ADDRESS_EXT(KLogTransportSubTag, aPostFrom, _L8("From:"));

	NM_LOG_ADDRESS_EXT(KLogTransportSubTag, aPostTo, _L8("To:"));

	NM_LOG_MESSAGE_EXT(KLogTransportSubTag, args, _L8("Msg:"));

	NM_LOG_END_BLOCK(KLogTransportSubTag, KNullDesC8);

#endif

	PostMessage(aPostFrom, aPostTo, TPtrC8(buf, args.Length()));

	}

class MBindingAwareTransportSender : public MCommsTransportSender

	{

public:

	virtual TBool TransportUsesBinding() const = 0;

	virtual void SetDropTransportPending(TBool aDropPending) = 0;

	virtual TBool IsDropTransportPending() const = 0;

	};

#ifndef SYMBIAN_NETWORKING_INTERTHREAD_TRANSPORT_ONLY

// Self-sending

class CTransportSelfSender : public CActive, public MBindingAwareTransportSender

	{

public:

	enum

		{

		};

	static CTransportSelfSender* NewL(MMessageDispatcher& aDispatcher, TWorkerId aSelfId);

private:

	//Legacy & helpers

	void PostMessage(const TCFMessage& aMessage);

	void PostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aMessage);

#ifdef SYMBIAN_CFTRANSPORT_SUPPORT_IMPATIENCE

	// From MTransportSender

	virtual TInt ImpatientPostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const Meta::SMetaData& aMessage);

	//Legacy & helpers

	TInt ImpatientPostMessage(const TCFMessage& aMessage);

	TInt ImpatientPostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aMessage);

#endif

#ifdef SYMBIAN_CFTRANSPORT_SUPPORT_SYNC_SEND

	void SendMessageSync(const TCFMessage& aMessage);

#endif

public:

	// From MBindingAwareTransportSender

	virtual TBool TransportUsesBinding() const

		{

		return EFalse;

		}

	virtual void SetDropTransportPending(TBool /*aDropPending*/)

		{

		// self-transports aren't droppable

		}

	virtual TBool IsDropTransportPending() const

		{

		return EFalse;

		}

	~CTransportSelfSender();

protected:

	void RunL();

	TInt RunError(TInt aError);

	void DoCancel();

private:

	CTransportSelfSender(MMessageDispatcher& aDispatcher, TWorkerId aSelfId);

	void ConstructL();

	TInt DoPostMessage(const TCFMessage& aMessage);

	TInt DoPostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aMessage);

	TInt ProcessMessage(TCFMessage2& aMessage, TInt aFirstDispatchLeaveReason);

	void MaybeTriggerReceipt();

private:

	TChipReceiver iReceiver;

	CCirBuf<TCFMessage>* iBuf;

	};

CTransportSelfSender::CTransportSelfSender(MMessageDispatcher& aDispatcher, TWorkerId aSelfId)

: CActive(EPriorityUserInput),

  iReceiver(aDispatcher, aSelfId)

	{

	}

CTransportSelfSender::~CTransportSelfSender()

	{

	Cancel();

	__CFLOG_VAR(( KLogCommsFw, KLogFwTransport, _L8("~CTransportSelfSender() - selfQ maxlen = %d"), iBuf->Length() ));

	delete iBuf;

	}

void CTransportSelfSender::ConstructL()

	{

	iBuf = new CCirBuf<TCFMessage>;

	iBuf->SetLengthL(KSelfSenderInitialQueueLength);

	}

CTransportSelfSender* CTransportSelfSender::NewL(MMessageDispatcher& aDispatcher, TWorkerId aSelfId)

	{

	CTransportSelfSender* self = new(ELeave) CTransportSelfSender(aDispatcher, aSelfId);

	CleanupStack::PushL(self);

	self->ConstructL();

	CActiveScheduler::Add(self);

	CleanupStack::Pop(self);

	return self;

	}

	{

	TInt newLen = iBuf->Length() + aAdditionalChips;

	__ASSERT_ALWAYS(newLen > iBuf->Count(), Panic(ECFInvalidQueueSize));

	// Create a new queue of the requisite size, copy the elements, and swap for the original

	// (there's no safe way to resize in-place).

	TCFMessage entry;

	while(iBuf->Remove(&entry))

		{

		VERIFY( newBuf->Add(&entry) );

		}

	delete iBuf;

	iBuf = newBuf;

	}

void CTransportSelfSender::PostMessage(const TCFMessage& aMessage)

	{

	TInt ret = DoPostMessage(aMessage);

	if(ret != KErrNone)

		{

		ret = DoPostMessage(aMessage);

		}

	}

void CTransportSelfSender::PostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aMessage)

	{

	__ASSERT_ALWAYS(aPostFrom.Size() + aPostTo.Size() + aMessage.Length() <= CommsFW::KMaxInlineMessageSize, User::Panic(KCFChannelPanic, ECFChanMsgTooBig));

	TInt ret = DoPostMessage(aPostFrom, aPostTo, aMessage);

	if(ret != KErrNone)

		{

		ret = DoPostMessage(aPostFrom, aPostTo, aMessage);

		}

	}

#ifdef SYMBIAN_CFTRANSPORT_SUPPORT_IMPATIENCE

/** Needs more testing before deployment

@internalTechnology

*/

TInt CTransportSelfSender::ImpatientPostMessage(const TCFMessage& aMessage)

	{

	return DoPostMessage(aMessage);

	}

/** Needs more testing before deployment

@internalTechnology

*/

TInt CTransportSelfSender::ImpatientPostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aMessage)

	{

	return DoPostMessage(aPostFrom, aPostTo, aMessage);

	}

#endif

TInt CTransportSelfSender::DoPostMessage(const TRuntimeCtxId& aPostFrom, const TRuntimeCtxId& aPostTo, const TDesC8& aMessage)

	{

#ifdef _DEBUG

	//Do not send a message to a NULL interface, if you need to address a thread, use

	//proper tier manager

	const TNodeId* nid = address_cast<TNodeId>(&aPostTo);

	if (nid && nid->Ptr()==NULL)

		{

		__CFLOG_VAR(( KLogCommsFw, KLogFwTransport, _L8("ERROR: CTransportSelfSender::DoPostMessage() posting to NULL") ));

		User::Panic(KCFTransportPanic,ECFTransInvalidCookie);

		}

#endif

	__ASSERT_ALWAYS(aPostFrom.Size() + aPostTo.Size() + aMessage.Length() <= CommsFW::KMaxInlineMessageSize, User::Panic(KCFChannelPanic, ECFChanMsgTooBig));	// Too big for chipper; send as blob

	TPtrC8 chipPtr(aMessage);

	TCFMessage2 msg(chipPtr, aPostFrom, aPostTo);

	if(chipPtr.Size() > 0)

		{

		TUint following = (chipPtr.Size() + TCFMessage::KMaxRawBlockSize - 1) / TCFMessage::KMaxRawBlockSize;

		TCFMessage2::SetChipsFollowing(following, msg);

		}

	const TCFMessage* msgPtr = &msg;

	TInt dataCarried;

	do

		{

		TInt err = DoPostMessage(*msgPtr);

		if(err != KErrNone)

			{

			// If en-queueing fails partway through chipping we can't punt the problem back to the caller to resolve

			// as they see fit since the half-sent sequence of chips is corrupt (will eat some following message or

			// underflow) and there's no (documentedly-safe) way to manipulate the ring buffer so as to erase the sent

			// chips. Our only hope is to try growing the buffer here; if this fails then the only option left is

			// panicking - to do better we need our own Deque so we can remove those chips

			if(msgPtr == &msg)

				{

				__CFLOG_VAR(( KLogCommsFw, KLogFwTransport, _L8("ERROR: CTransportSelfSender::DoPostMessage() queue overflow") ));

				// First chip, safe to error

				return KErrOverflow;

				}

			else

				{

				err = DoPostMessage(*msgPtr);

				if(err != KErrNone)

					{

					Panic(ECFTransPeerDrainFailure);	// true, even though peer is us... should try growing ring buf

					}

				}

			}

		dataCarried = Min(chipPtr.Size(), sizeof(*msgPtr));

		// By strict definition all of the (raw) data in a TCFMessage is payload and word-aligned so the following

		// cast must be safe, except when moving on from the final chip, in which case msgPtr could be unaligned but

		// will never be derefenced further since the loop then terminates

		msgPtr = reinterpret_cast<const TCFMessage*>(chipPtr.Ptr());

		chipPtr.Set(chipPtr.Mid(dataCarried));

		} while(dataCarried > 0);

	return KErrNone;

	}

TInt CTransportSelfSender::DoPostMessage(const TCFMessage& aMessage)

	{

#ifdef SYMBIAN_CFTRANSPORT_ALL_OWN_THREAD_MSGS_DIRECT_DISPATCH

#pragma message("!!KLUDGE ALERT!! SYMBIAN_CFTRANSPORT_ALL_OWN_THREAD_MSGS_DIRECT_DISPATCH")

	// The receiver gets its own modifiable copy of the message

	TCFMessage2& msg = iReceiver.NextChipStore();

	msg = aMessage;

	TRAPD(err, iReceiver.ProcessChipL(KErrNone));

	if(err != KErrNone)

		{

		TRAP(err, iReceiver.ProcessChipL(KErrNone));	// we ignore err; this is already their error handler

		}

	return KErrNone;

#else

	if(!iBuf->Add(&aMessage))

		{

		return KErrOverflow;

		}

	if(!IsActive())

		{

		MaybeTriggerReceipt();

		}

	return KErrNone;

#endif

	}

#ifdef SYMBIAN_CFTRANSPORT_SUPPORT_SYNC_SEND

void CTransportSelfSender::SendMessageSync(const TCFMessage& aMessage)

	{

	// The receiver gets its own modifiable copy of the message

	iReceiver.NextChipStore() = aMessage;

	TRAPD(err, iReceiver.ProcessChipL(KErrNone));

	if(err != KErrNone)

		{

		TRAP(err, iReceiver.ProcessChipL(KErrNone));	// we ignore err; this is already their error handler

		}

	}

#endif

void CTransportSelfSender::RunL()

	{

	VERIFY_RESULT(iBuf->Remove(&iReceiver.NextChipStore()), 1);

	iReceiver.ProcessChipL(KErrNone);

	MaybeTriggerReceipt();

	}

TInt CTransportSelfSender::RunError(TInt aError)

	{

	TRAPD(err, iReceiver.ProcessChipL(aError));

	if(err != KErrNone)

		{

		// This is a fatal error because a common requirement for handling the first leave is sending

		// an error signal; leaving again suggests that the code is not handling the possibility of a Leave()

		// properly, rather than explicitly opting to ignore it.

		Panic(ECFTransLeaveFromLeaveHandler);