// Copyright (c) 2004-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 "ss_subconnflow.h"

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_mcprnodemessages.h>

#include <comms-infras/ss_protflow.h>

#include <es_ini.h>

#include <ss_glob.h>

#include <ss_protprov.h>

#include <comms-infras/ss_sapshim.h>

#include "ss_sapfactshim.h"

#include <elements/cftransport.h>

#include <ecom/ecom.h>

#include <elements/nm_messages_child.h>

#include <comms-infras/ss_nodemessages_factory.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_ESockSSocksbcnfl, "ESockSSocksbcnfl");

#endif

using namespace ESock;

using namespace Messages;

using namespace CommsFW;

using namespace Factories;

//-=====================================================================

//

//

// CSubConnectionFlowFactoryContainer

//

//

//-=====================================================================

CSubConnectionFlowFactoryContainer::CSubConnectionFlowFactoryContainer()

:CCommsFactoryContainer((CCommsFactoryContainer::TContaineeType)CSubConnectionFlowFactoryContainer::EId)

	{

	LOG_NODE_CREATE(KESockDataFactTag, CSubConnectionFlowFactoryContainer)

	}

CSubConnectionFlowFactoryContainer::~CSubConnectionFlowFactoryContainer()

	{

	TCFLegacyMessage::DeRegister();

	LOG_NODE_DESTROY(KESockDataFactTag, CSubConnectionFlowFactoryContainer)

	}

CSubConnectionFlowFactoryContainer* CSubConnectionFlowFactoryContainer::NewL()

/** Create a new instance of a sub-connection factory container

@exception Leaves in out of memory conditions

@return Pointer to new instance of a sub-connection factory container

*/

	{

	using namespace CommsFW;

	LOG( ESockLog::Printf(KESockDataFactTag, _L8("CSubConnectionFlowFactoryContainer:\tNewL()")) );

	// For the self-dispatching TLegacyConnectionEnumRequest

	TCFLegacyMessage::RegisterL();

	CSubConnectionFlowFactoryContainer* provcont = new (ELeave) CSubConnectionFlowFactoryContainer();

	CleanupStack::PushL(provcont);

	CTransportFlowShimFactory::NewL(TUid::Uid(CTransportFlowShimFactory::iUid), *provcont);

	CleanupStack::Pop(provcont);

	return provcont;

	}

void CSubConnectionFlowFactoryContainer::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& /*aRecipient*/, TSignatureBase& aMessage)

	{

	if (aMessage.IsMessage<TCFFactory::TFindOrCreatePeer>())

		{

		TCFFactory::TFindOrCreatePeer& msg = message_cast<TCFFactory::TFindOrCreatePeer>(aMessage);

		CCommsFactoryBase* factory = static_cast<CCommsFactoryBase*>(FindOrCreateFactoryL(msg.iUid));

        ACommsFactoryNodeId* flow = factory->FindOrCreateObjectL(*(msg.iQuery));

        // Send "DataClientJoined"

   #ifndef __GCCXML__

   	    RClientInterface::OpenPostMessageClose(Id(), aSender,

   	    	TCFFactory::TPeerFoundOrCreated(flow? flow->Id() : TNodeId::NullId(), 0).CRef());

   #endif

        aMessage.ClearMessageId();

		}

	else

		{

		NM_LOG_START_BLOCK(KESockMetaConnectionTag, _L8("CSubConnectionFlowFactoryContainer:ReceivedL"));

		NM_LOG((KESockMetaConnectionTag, _L8("ERROR: KErrNotSupported [this=0x%08x] "), this));

		NM_LOG_MESSAGE(KESockMetaConnectionTag, aMessage);

        NM_LOG_END_BLOCK(KESockMetaConnectionTag, _L8("CSubConnectionFlowFactoryContainer:ReceivedL"));

		__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSocksbcnfl, 1)); //For debug configurations

		User::Leave(KErrNotSupported); //For release configurations

		}

	}

//-=====================================================================

//

//

// CSubConnectionFlowFactoryBase

//

//

//-=====================================================================

EXPORT_C CSubConnectionFlowFactoryBase::CSubConnectionFlowFactoryBase(TUid aFactoryId, CSubConnectionFlowFactoryContainer& aParentContainer)

/** Sub-connection flow factory constructor

@param aFactoryId Unique Integer Identifier of the sub-connection provider factory

@param aParentContainer Container to add the factory to */

	: CCommsFactoryBase(aFactoryId, aParentContainer)

	{

	}

EXPORT_C ACommsFactoryNodeId* CSubConnectionFlowFactoryBase::DoCreateObjectL(TFactoryQueryBase& aQuery)

	{

	const TDefaultFlowFactoryQuery& flowQuery = static_cast<const TDefaultFlowFactoryQuery&>(aQuery);

	TDefaultProtocolIntfFactoryQuery pintfQuery (flowQuery.iCprId);

	CProtocolIntfBase* proto = SockManGlobals::Get()->iProtocolIntfFactories->FindOrCreateProtocolIntfL(Uid(), pintfQuery);

	if (NULL == proto)

    	{

    	LOG( ESockLog::Printf(KESockDataFactTag, _L8("CSubConnectionFlowFactoryBase %08x:\tCreateFlowL(protocolId '%08x') Cannot find protocol interface, bailing out"), this, Uid()) );

    	User::Leave(KErrNotFound);

    	}

    // A null CPR indicates that there is no real control side at all, meaning it's a legacy protocol and the FlowRequest is puppeteering this

    // creation. In such a case we must be creating a CTransportFlowShim, which understands that a null SCPR is to be ignored

    __ASSERT_DEBUG(!flowQuery.iCprId.IsNull() || proto->Factory().Uid().iUid == CTransportFlowShimFactory::iUid, User::Panic(KSpecAssert_ESockSSocksbcnfl, 2));

    ACommsFactoryNodeId* flow = DoCreateFlowL(proto, aQuery);

	LOG( ESockLog::Printf(KESockDataFactTag, _L8("CSubConnectionFlowFactoryBase %08x:\tCreateFlowL(protocolId '%08x'): flow %08x"), this, Uid(), &flow) );

	return flow;

	}

EXPORT_C TServerProtocolDesc* CSubConnectionFlowFactoryBase::CreateFlowDescriptionL(TInt aProtocol)

	{

	// Defer to derived implementation

	return DoCreateFlowDescriptionL(aProtocol);

	}

EXPORT_C TServerProtocolDesc* CSubConnectionFlowFactoryBase::DoCreateFlowDescriptionL(TInt /*aProtocol*/)

	{

	__ASSERT_DEBUG(0, Panic(EMisconfigured));

	User::Leave(KErrNotSupported);

	return NULL;

	}

EXPORT_C CSubConnectionFlowFactoryBase::~CSubConnectionFlowFactoryBase()

	{

	}

//-=====================================================================

// Default PINT

//-=====================================================================

class CDefaultProtocolIntf : public CProtocolIntfBase

/**

This is the internal, dummy, default CProtocolIntfBase implementation

that will by default accompany any flow unless the flow factory

decides to overload its CreateProtocolIntfFactoryL method.

@internalTechnology

*/

	{

public:

	CDefaultProtocolIntf(CProtocolIntfFactoryBase& aFactory,const Messages::TNodeId& aCprId);

	// from CProtocolIntfBase

	virtual void DoFlowCreated(ESock::CSubConnectionFlowBase& aFlow);

	virtual void DoFlowBeingDeleted(ESock::CSubConnectionFlowBase& aFlow);

	};

class CDefaultProtocolIntfFactory : public CProtocolIntfFactoryBase

/**

This is the internal, dummy, default CProtocolIntfBase implementation

that will by default accompany any flow unless the flow factory

decides to overload its CreateProtocolIntfFactoryL method.

@internalTechnology

*/

	{

public:

	virtual CProtocolIntfBase* DoCreateProtocolIntfL(TFactoryQueryBase& aQuery);

	static CDefaultProtocolIntfFactory* NewL(TUid aFactoryId, ESock::CProtocolIntfFactoryContainer& aParentContainer);

protected:

	CDefaultProtocolIntfFactory(TUid aFactoryId, ESock::CProtocolIntfFactoryContainer& aParentContainer);

	};

CDefaultProtocolIntfFactory* CDefaultProtocolIntfFactory::NewL(TUid aFactoryId, ESock::CProtocolIntfFactoryContainer& aParentContainer)

	{

    CDefaultProtocolIntfFactory* factory = new (ELeave) CDefaultProtocolIntfFactory(aFactoryId, aParentContainer);

    CleanupStack::PushL(factory);

    factory->ConstructL();

    CleanupStack::Pop(factory);

    return factory;

	}

CDefaultProtocolIntf::CDefaultProtocolIntf(CProtocolIntfFactoryBase& aFactory,const Messages::TNodeId& aCprId)

:CProtocolIntfBase(aFactory,aCprId)

    {

    }

void CDefaultProtocolIntf::DoFlowCreated(ESock::CSubConnectionFlowBase& /*aFlow*/)

    {

    }

void CDefaultProtocolIntf::DoFlowBeingDeleted(ESock::CSubConnectionFlowBase& /*aFlow*/)

    {

    }

CProtocolIntfBase* CDefaultProtocolIntfFactory::DoCreateProtocolIntfL(TFactoryQueryBase& aQuery)

    {

    const TDefaultProtocolIntfFactoryQuery& query = static_cast<const TDefaultProtocolIntfFactoryQuery&>(aQuery);

    return new (ELeave) CDefaultProtocolIntf(*this,query.iCprId);

    }

CDefaultProtocolIntfFactory::CDefaultProtocolIntfFactory(TUid aFactoryId, CProtocolIntfFactoryContainer& aParentContainer)

:	CProtocolIntfFactoryBase(aFactoryId, aParentContainer)

    {

	}

EXPORT_C CProtocolIntfFactoryBase* CSubConnectionFlowFactoryBase::CreateProtocolIntfFactoryL(CProtocolIntfFactoryContainer& aParentContainer)

    {

    return CDefaultProtocolIntfFactory::NewL (Uid(), aParentContainer);

    }

//-=====================================================================

//

//

// CSubConnectionFlowBase

//

//

//-=====================================================================

EXPORT_C CSubConnectionFlowBase::CSubConnectionFlowBase(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId,

                                                        CProtocolIntfBase* aProtocolIntf)

:	ACommsFactoryNodeId(aFactory),

	iProtocolIntf(aProtocolIntf)

	{

	__ASSERT_DEBUG(iProtocolIntf, User::Panic(KSpecAssert_ESockSSocksbcnfl, 3));

    iSubConnectionProvider.Open(aSubConnId);

	// Signal the ProtocolIntf that a Flow has been created.

	iProtocolIntf->FlowCreated(*this);

	}

EXPORT_C CSubConnectionFlowBase::~CSubConnectionFlowBase()

	{

	if(iLastRequestOriginator.IsOpen())

		{

		iLastRequestOriginator.ReplyTo(Id(), TEChild::TLeft().CRef());

		}

    iProtocolIntf->FlowBeingDeleted(*this);

	LOG( ESockLog::Printf(KESockDataFactTag, _L8("CSubConnectionFlowBase %08x:\t~CSubConnectionFlowBase"), this) );

	}

EXPORT_C void CSubConnectionFlowBase::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& /*aRecipient*/, TSignatureBase& aMessage)

    {

    if (iLastRequestOriginator.Open(iSubConnectionProvider, aSender) != KErrNone)

        {

        if(!iSubConnectionProvider.IsOpen())

	        {

	    	// Legacy flows legitimately lack a sub-connection provider

	        return;

	        }

		else if(aMessage.IsMessage<TEBase::TError>())

			{

			//[TODO EC120] RZ: WHoa! What is this?! Flow receives a TError and as a response sends TError

			//(leaves from ::ReceivedL are handled by sending TError).

			__ASSERT_DEBUG(static_cast<TEBase::TError&>(aMessage).iValue != KErrNone, User::Panic(KSpecAssert_ESockSSocksbcnfl, 4));

			User::Leave(static_cast<TEBase::TError&>(aMessage).iValue);	// don't mutate the error into KErrArgument

			}

		User::Leave(KErrArgument);

        }

    }

EXPORT_C void CSubConnectionFlowBase::SubConnectionGoingDown()

	{

	LOG( ESockLog::Printf(KESockDataFactTag, _L8("CSubConnectionFlowBase %08x:\tSubConnectionGoingDown"), this) );

	iSubConnectionProvider.Close();

	DeleteThisFlow();

	}

EXPORT_C NetInterfaces::TInterfaceControl* CSubConnectionFlowBase::FetchNodeInterfaceControlL(TInt aInterfaceId)

    {

    return DoFetchInterfaceControlL(aInterfaceId);

    }

EXPORT_C MFlowBinderControl* CSubConnectionFlowBase::GetBinderControlL()

	{

	return DoGetBinderControlL();

	}

EXPORT_C void CSubConnectionFlowBase::DeleteThisFlow()

/**

Called from Flows to delete themselves, usually as a result of a received Destroy() message.

*/

	{

	DeleteMeNow();

	// "this" no longer valid after this point.

	}

EXPORT_C CProtocolIntfBase* CSubConnectionFlowBase::ProtocolIntf() const

/**

Return the ProtocolIntf associated with this Flow

*/

	{

	return iProtocolIntf;

	}