// Copyright (c) 2008-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:
// Dummy implementation file for network tier flow
//
//

/**
 @file
 @internalComponent
*/


#include <ss_std.h>
#include <comms-infras/ss_log.h>
#include <ss_pman.h>
#include <comms-infras/ss_nodemessages_internal_esock.h>
#include <comms-infras/ss_protocolparameterset.h>
#include "dummypr_flow.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_ESockTestdmyprnt, "ESockTestdmyprnt");
#endif

using namespace ESock;
using namespace Messages;




// Construction
//-------------
CDummyFlow* CDummyFlow::NewL(CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConn, CProtocolIntfBase* aProtocolIntf)
	{
	CDummyFlow* self = new (ELeave) CDummyFlow(aFactory, aSubConn, aProtocolIntf);
	return self;
	}

CDummyFlow::CDummyFlow(CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConn, CProtocolIntfBase* aProtocolIntf)
: CSubConnectionFlowBase(aFactory, aSubConn, aProtocolIntf)
	{
    LOG_NODE_CREATE(KESockFlowTag, CDummyFlow)
	}

CDummyFlow::~CDummyFlow()
	{
    LOG_NODE_DESTROY(KESockFlowTag, CDummyFlow)
	}

MSessionControl* CDummyFlow::GetControlL(
	TInt /*aSessionType*/,
	MSessionControlNotify& aSessionControlNotify)
    {
	// Apply binding locally
	__ASSERT_DEBUG(iSessionControlNotify == NULL, User::Panic(KSpecAssert_ESockTestdmyprnt, 1));
	iSessionControlNotify = &aSessionControlNotify;

	return this;
    }

MSessionData* CDummyFlow::BindL(MSessionDataNotify& aNotify)
    {
	LOG( ESockLog::Printf(_L8("CDummyFlow %08x:\tBindL(aNotify 0x%08x)"), this, &aNotify) );

	// Apply binding locally
	__ASSERT_DEBUG(iSessionDataNotify == NULL, User::Panic(KSpecAssert_ESockTestdmyprnt, 3));
	iSessionDataNotify = &aNotify;
	iSubConnectionProvider.RNodeInterface::PostMessage(
		Id(),
		TCFControlProvider::TActive().CRef());
	return this;
    }

void CDummyFlow::Unbind()
    {
	LOG( ESockLog::Printf(_L8("CDummyFlow %08x:\tUnbind()"), this) );
	ASSERT(iSessionDataNotify); //who else is it calling then?

    iSessionControlNotify = NULL;
    iSessionDataNotify = NULL;

    ASSERT(iSubConnectionProvider.IsOpen());
    iSubConnectionProvider.RNodeInterface::PostMessage(
        Id(),
        TCFControlProvider::TIdle().CRef()
        );
    }

ESock::CSubConnectionFlowBase& CDummyFlow::CloneFlowL()
    {
    TDefaultFlowFactoryQuery query (iProtocolIntf->ControlProviderId(), iSubConnectionProvider.RecipientId());

	ESock::CSubConnectionFlowBase& flow = static_cast<ESock::CSubConnectionFlowBase&>(*(Factory().CreateObjectL(query)));

	// Have the new flow become a data client of our subconnection too
	__ASSERT_DEBUG(iSubConnectionProvider.IsOpen(), User::Panic(KSpecAssert_ESockTestdmyprnt, 6));
	TCFPeer::TJoinRequest msg(
		flow.Id(),
		TCFClientType(TCFClientType::EData, TCFClientType::EActive)
		);

	iSubConnectionProvider.PostMessage(Id(), msg);

	return flow;
    }

CSubConnectionFlowBase* CDummyFlow::Flow()
	{
	return this;
	}


// MSessionControl
//----------------
void CDummyFlow::Start()
	{/*__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 7)); return iLowerFlowControl->Start()*/;}

void CDummyFlow::LocalName(TSockAddr& anAddr) const
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 8)); return iLowerFlowControl->LocalName(anAddr);}

void CDummyFlow::SetLocalName(TSockAddr& /*anAddr*/)
	{
    // Fetch the current flow parameters (those that were sent to us) and create a new set for the flow we want
    TFlowParams flowParams;
    flowParams.iProtocol = CDummyFlow::EProtocolId;
    flowParams.iSocketType = KSockDatagram;

    // Create and load a parameter set with the flow parameters that form our binder request
    CFlowRequestParameters* paramSet = CFlowRequestParameters::NewL();
    CleanupStack::PushL(paramSet);
    paramSet->SetFlowParams(flowParams);
    RCFParameterFamilyBundle flowParamsBundle;
    flowParamsBundle.CreateL();
    RParameterFamily family = flowParamsBundle.CreateFamilyL(KFlowParametersFamily);
    family.AddParameterSetL(paramSet, RParameterFamily::ERequested);

    iParamBundle.Open(flowParamsBundle);
    // Construct and send the message
    iSubConnectionProvider.RNodeInterface::PostMessage(
        Id(),
        TCFControlProvider::TNoBearer(iParamBundle).CRef()
        );

    CleanupStack::Pop(paramSet);
 	}

void CDummyFlow::RemName(TSockAddr& anAddr) const
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 10)); iLowerFlowControl->RemName(anAddr);}

TInt CDummyFlow::SetRemName(TSockAddr& anAddr)
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 11)); return iLowerFlowControl->SetRemName(anAddr);}

const TInt KDummyNetworkFlowOptionLevel = CDummyFlowFactory::iUid;
const TInt KFlowProtocolName = 1;

TInt CDummyFlow::GetOption(TUint aLevel, TUint aName, TDes8& anOption) const
	{
	__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 12));

	if(aLevel == KDummyNetworkFlowOptionLevel && aName == KFlowProtocolName)
		{
		anOption.Copy(KDummyProtocolName);
		return KErrNone;
		}
	else
		{
		return iLowerFlowControl->GetOption(aLevel, aName, anOption);
		}
	}

void CDummyFlow::Ioctl(TUint aLevel, TUint aName, TDes8* anOption)
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 13)); iLowerFlowControl->Ioctl(aLevel, aName, anOption);}

void CDummyFlow::CancelIoctl(TUint aLevel, TUint aName)
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 14)); iLowerFlowControl->CancelIoctl(aLevel, aName);}

TInt CDummyFlow::SetOption(TUint /*aLevel*/, TUint /*aName*/, const TDesC8 &/*anOption*/)
	{ return KErrNone; }

void CDummyFlow::ActiveOpen()
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 16)); iLowerFlowControl->ActiveOpen();}

void CDummyFlow::ActiveOpen(const TDesC8& aConnectionData)
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 17)); iLowerFlowControl->ActiveOpen(aConnectionData);}

TInt CDummyFlow::PassiveOpen(TUint aQueueSize)
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 18)); return iLowerFlowControl->PassiveOpen(aQueueSize);}

TInt CDummyFlow::PassiveOpen(TUint aQueueSize, const TDesC8& aConnectionData)
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 19)); return iLowerFlowControl->PassiveOpen(aQueueSize, aConnectionData);}

void CDummyFlow::Shutdown(MSessionControl::TCloseType aOption)
	{ 
    if (iLowerFlowControl)
        { 
        iLowerFlowControl->Shutdown(aOption);
        }
    else
        {
        iSessionControlNotify->CanClose(MSessionControlNotify::EDelete);
        }
	}

void CDummyFlow::Shutdown(MSessionControl::TCloseType aOption, const TDesC8& aDisconnectionData)
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 21)); iLowerFlowControl->Shutdown(aOption, aDisconnectionData);}

void CDummyFlow::AutoBind()
	{__ASSERT_DEBUG(iLowerFlowControl, User::Panic(KSpecAssert_ESockTestdmyprnt, 22));	iLowerFlowControl->AutoBind();}

TInt CDummyFlow::SecurityCheck(MProvdSecurityChecker* /*aChecker*/)
	{ return KErrNone;}


// MSessionData
//-------------
TUint CDummyFlow::Write(const TDesC8& aDesc, TUint aOptions, TSockAddr* anAddr)
	{__ASSERT_DEBUG(iLowerFlowData, User::Panic(KSpecAssert_ESockTestdmyprnt, 24));	return iLowerFlowData->Write(aDesc, aOptions, anAddr);}

TInt CDummyFlow::Write(RMBufChain& aData, TUint aOptions, TSockAddr* anAddr)
	{__ASSERT_DEBUG(iLowerFlowData, User::Panic(KSpecAssert_ESockTestdmyprnt, 25));	return iLowerFlowData->Write(aData, aOptions, anAddr);}

void CDummyFlow::GetData(TDes8& aDesc, TUint aOptions, TSockAddr* anAddr)
	{__ASSERT_DEBUG(iLowerFlowData, User::Panic(KSpecAssert_ESockTestdmyprnt, 26));	iLowerFlowData->GetData(aDesc, aOptions, anAddr);}

TInt CDummyFlow::GetData(RMBufChain& aData, TUint aLength, TUint aOptions, TSockAddr* anAddr)
	{__ASSERT_DEBUG(iLowerFlowData, User::Panic(KSpecAssert_ESockTestdmyprnt, 27));	return iLowerFlowData->GetData(aData, aLength, aOptions, anAddr);}


// MSessionControlNotify
//----------------------
void CDummyFlow::ConnectComplete()
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 28));	iSessionControlNotify->ConnectComplete();}

void CDummyFlow::ConnectComplete(const TDesC8& aConnectData)
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 29));	iSessionControlNotify->ConnectComplete(aConnectData);}

void CDummyFlow::ConnectComplete(CSubConnectionFlowBase& anSSP)
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 30));	iSessionControlNotify->ConnectComplete(anSSP);}

void CDummyFlow::ConnectComplete(CSubConnectionFlowBase& anSSP,const TDesC8& aConnectData)
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 31));	iSessionControlNotify->ConnectComplete(anSSP, aConnectData);}

void CDummyFlow::CanClose(MSessionControlNotify::TDelete aDelete)
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 32));	iSessionControlNotify->CanClose(aDelete);}

void CDummyFlow::CanClose(
	const TDesC8& aDisconnectData,
	MSessionControlNotify::TDelete aDelete)
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 33));	iSessionControlNotify->CanClose(aDisconnectData, aDelete);}

TInt CDummyFlow::Error(TInt anError,TUint anOperationMask)
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 34));	return iSessionControlNotify->Error(anError, anOperationMask);}

void CDummyFlow::Disconnect()
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 35));	iSessionControlNotify->Disconnect();}

void CDummyFlow::Disconnect(TDesC8& aDisconnectData)
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 36));	iSessionControlNotify->Disconnect(aDisconnectData);}

void CDummyFlow::IoctlComplete(TDesC8* aBuf)
	{__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 37));	iSessionControlNotify->IoctlComplete(aBuf);}

void CDummyFlow::DisconnectFromListener(CSubConnectionFlowBase& aSSP)
	{
		__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 53));
        iSessionControlNotify->DisconnectFromListener(aSSP);
    }
void CDummyFlow::SetLocalNameComplete()
	{
	__ASSERT_DEBUG(iSessionControlNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 52));
	iSessionControlNotify->SetLocalNameComplete();
	}

// MSessionDataNotify
//-------------------
void CDummyFlow::NewData(TUint aCount)
	{__ASSERT_DEBUG(iSessionDataNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 39)); iSessionDataNotify->NewData(aCount);}

void CDummyFlow::CanSend()
	{__ASSERT_DEBUG(iSessionDataNotify, User::Panic(KSpecAssert_ESockTestdmyprnt, 40)); iSessionDataNotify->CanSend();}

MFlowBinderControl* CDummyFlow::DoGetBinderControlL()
	{
	return this;
	}


// Node stuff
//-----------
void CDummyFlow::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)
    {
    CSubConnectionFlowBase::ReceivedL(aSender, aRecipient, aMessage);
    TInt err = KErrNone;
    
	if ( aMessage.IsMessage<TEBase::TError>() )
		{
		ASSERT(EFalse); //To be implemented
		}
	else if ( aMessage.IsMessage<TCFControlProvider::TBearer>() )
        {
        }
	else if (aMessage.IsMessage<TCFInternalEsock::TFlowProvision>())
	    {
	    }
	else if (TEChild::ERealmId == aMessage.MessageId().Realm())
		{
		switch (aMessage.MessageId().MessageId())
			{
		case TEChild::TDestroy::EId :
		    DeleteThisFlow();
			break;
		default:
			__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockTestdmyprnt, 41)); //For debug configurations
			User::Leave(KErrNotSupported); //For release configurations
			}
		}
	else if (TCFDataClient::ERealmId == aMessage.MessageId().Realm())
		{
		switch (aMessage.MessageId().MessageId())
			{
		case TCFDataClient::TStart::EId :
		    iSubConnectionProvider.PostMessage(Id(), TCFDataClient::TStarted().CRef());
			break;
		case TCFDataClient::TStop::EId :
            iParamBundle.Close(); //[RZ] There is a problem with RCFParameterBundle. Nominally this should be cleared (closed) on TBeaer
                                  //but that means that this thread (which constructed the bundle) will call Close before the recipient
                                  //refcounting will mean that it's the recipient that would then dealocate and crash against different heap.
                                  //Best if RCFParameterBundle were changed. Alternativelly, CNoBearer could get rid of the params 
                                  //earlier.

		    if (iLowerFlowBinderControl)
		           {
		           iLowerFlowBinderControl->Unbind(NULL,NULL);
		           iLowerFlowBinderControl->Unbind();
		           iLowerFlowBinderControl = NULL;
		           iLowerFlowControl = NULL;
		           iLowerFlowData = NULL;
		           }

		       iSubConnectionProvider.PostMessage(Id(), TCFDataClient::TStopped(
                           message_cast<TCFDataClient::TStop>(aMessage).iValue).CRef());
			break;
		case TCFDataClient::TProvisionConfig::EId:
			break;
		case TCFDataClient::TBindTo::EId:
		    {
			TCFDataClient::TBindTo& bindToMsg(static_cast<TCFDataClient::TBindTo&>(aMessage));
			TRAP(err, BindToL(bindToMsg));

	        if(err == KErrNone)
	            {
	            RClientInterface::OpenPostMessageClose(Id(), aSender, TCFDataClient::TBindToComplete().CRef());
	            }
	        else
	            {
	            RClientInterface::OpenPostMessageClose(Id(), aSender, TEBase::TError(aMessage.MessageId(), err).CRef());
	            }
	        
			if (iSessionControlNotify && !iParamBundle.IsNull())
			    {
                iSessionControlNotify->SetLocalNameComplete();
			    }
		    }
			break;
		default:
			__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockTestdmyprnt, 42)); //For debug configurations
			User::Leave(KErrNotSupported); //For release configurations
			}
		}
	else
		{
    	__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockTestdmyprnt, 45)); //For debug configurations
    	User::Leave(KErrNotSupported); //For release configurations
		}
    }

void CDummyFlow::BindToL(TCFDataClient::TBindTo& aBindTo)
/**
Request from control side (at network layer) to indicate that the SubConnection is
up and running and that we should bind to a Flow below.

@param aLowerFlow Flow below to bind to.
*/
	{
	//provisioning message must come before bindto in case we didn't get it after we've joined
	//the sub-connection
    if (aBindTo.iNodeId == Messages::TNodeId::NullId())
        {
        return;
        }
	NM_LOG((KESockServerTag, _L8("CDummyFlow %08x:\tSynchronous call: From=%08x To=%08x Func=BindToL"),
			this, static_cast<Messages::ANode*>(this), &aBindTo.iNodeId.Node()) )

	const TNodeId& commsId = aBindTo.iNodeId;

#if defined(__GCCXML__)
    CSubConnectionFlowBase* flow = reinterpret_cast<CSubConnectionFlowBase*>(&commsId.Node());
#else
	CSubConnectionFlowBase* flow = Messages::mnode_cast<CSubConnectionFlowBase>(&commsId.Node());
#endif

	// Flows can only be directly bound when running in the same thread
	__ASSERT_DEBUG(commsId.Thread() == Id().Thread(), User::Panic(KSpecAssert_ESockTestdmyprnt, 47));

	if (iLowerFlowBinderControl && iLowerFlowBinderControl->Flow() != flow )
		{
		// Already bound to something else so unbind first
		iLowerFlowBinderControl->Unbind(NULL,NULL);
		iLowerFlowBinderControl = NULL;

		iLowerFlowBinderControl->Unbind();
		iLowerFlowControl = NULL;
		iLowerFlowData = NULL;
		}

	if (iLowerFlowBinderControl == NULL)
		{
		// Protocol binding
		iLowerFlowBinderControl = flow->GetBinderControlL();
		iLowerFlowControl = iLowerFlowBinderControl->GetControlL(KSockDatagram, *this);
		iLowerFlowData = iLowerFlowBinderControl->BindL(*this);
		}
	}