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

// IP SubConnection Provider implementation

// 

//

/**

 @file

 @internalComponent

*/

#include "ipscpr.h"

#include "ipdeftbasescpr.h"

#include "ipscprlog.h"

#include "ipscprstates.h"

#include <comms-infras/ss_log.h>

#include "IPMessages.h"

#include <comms-infras/ss_msgintercept.h>

#include <elements/nm_signatures.h>

#include <comms-infras/ss_nodemessages_factory.h>

#if defined __FLOG_ACTIVE || defined SYMBIAN_TRACE_ENABLE

	#define KIPSCprTag KESockSubConnectionTag

	//_LIT8(KIPSCprSubTag, "ipscpr");

#endif

using namespace MeshMachine;

using namespace Messages;

using namespace ESock;

using namespace NetStateMachine;

//We reserve space for two preallocated activities that may start concurrently on the SCPR

//node: destroy and data client stop.

static const TUint KDefaultMaxPreallocatedActivityCount = 2;

static const TUint KMaxPreallocatedActivitySize = sizeof(MeshMachine::CNodeRetryParallelActivity) + sizeof(MeshMachine::APreallocatedOriginators<4>);

static const TUint KIPSCPRPreallocatedActivityBufferSize = KDefaultMaxPreallocatedActivityCount * KMaxPreallocatedActivitySize;

namespace IPSCprAddressUpdate

{

DECLARE_DEFINE_NODEACTIVITY(IPDeftSCprBaseActivities::ECFActivityAddressUpdate, IPSCprAddressUpdate, TCFIPMessage::TDataClientRouted)

	NODEACTIVITY_ENTRY(KNoTag, IPBaseSCprStates::TStoreAddressUpdate, IPBaseSCprStates::TAwaitingAddressUpdate, IpSCprStates::TNoTagOrDoNothingTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, IpSCprStates::TCreateAddressInfoBundle, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, IpSCprStates::TSendSelfStart, CoreNetStates::TAwaitingStarted, IpSCprStates::TDoNothingTag)

	LAST_NODEACTIVITY_ENTRY(IpSCprStates::KDoNothingTag, MeshMachine::TDoNothing)

NODEACTIVITY_END()

}

#ifndef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

namespace IPSCprParamsRequest

{

DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, IPSCprSetParams, TCFScpr::TParamsRequest)

	FIRST_NODEACTIVITY_ENTRY(SCprStates::TAwaitingParamRequest, CoreNetStates::TNoTagOrBearerPresent)

	NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, SCprStates::TPassToServiceProvider, CoreNetStates::TAwaitingParamResponse, CoreNetStates::TBearerPresent)

	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, SCprStates::TStoreParamsAndPostToOriginators)

	LAST_NODEACTIVITY_ENTRY(KNoTag, SCprStates::TStoreAndRespondWithCurrentParams)

NODEACTIVITY_END()

}

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

namespace IPSCprApplyRequest

{

DECLARE_DEFINE_NODEACTIVITY(ECFActivityApplyChanges, IpSCprApplyReq, TCFScpr::TApplyRequest)

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingApplyRequest, IpSCprStates::TNoTagOrSendApplyResponseOrErrorTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, IpSCprStates::TCreateAddressInfoBundleFromJoiningClient, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, IpSCprStates::TSendSelfStart, CoreNetStates::TAwaitingStarted, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, PRStates::TSendApplyResponse)

	LAST_NODEACTIVITY_ENTRY(SCprActivities::Apply::ESendApplyResponse, PRStates::TSendApplyResponse)

#else

	FIRST_NODEACTIVITY_ENTRY(SCprStates::TAwaitingApplyRequest, IpSCprStates::TNoTagOrSendApplyResponseOrErrorTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, IpSCprStates::TCreateAddressInfoBundleFromJoiningClient, MeshMachine::TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, IpSCprStates::TSendSelfStart, CoreNetStates::TAwaitingStarted, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, SCprStates::TSendApplyResponse)

	LAST_NODEACTIVITY_ENTRY(SCprActivities::Apply::ESendApplyResponse, SCprStates::TSendApplyResponse)

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TRaiseActivityError)

NODEACTIVITY_END()

}

namespace IPSCprStartActivity

{

//TODO perhaps get this from a header file since its used in a number of places - see ss_subconn.cpp

typedef MeshMachine::TAcceptErrorState<CoreNetStates::TAwaitingApplyResponse> TAwaitingApplyResponseOrError;

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStart, IPSCprStart, TCFServiceProvider::TStart, PRActivities::CStartActivity::NewL)

    FIRST_NODEACTIVITY_ENTRY(MeshMachine::TAwaitingMessageState<TCFServiceProvider::TStart>, IpSCprStates::TNoTagOrBearerPresentBlockedByStopOrBindTo)

	NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, CoreNetStates::TBindSelfToPresentBearer, CoreNetStates::TAwaitingBindToComplete, MeshMachine::TTag<CoreNetStates::KBearerPresent>)

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendNoBearer, MeshMachine::TAwaitingMessageState<TCFControlProvider::TBearer>, MeshMachine::TTag<CoreNetStates::KBearerPresent>)

	//[401TODO] RZ: this tuple is the only thing that distinguishes this activity from the core although, the core should look

	//like this one - i.e.: sending params down on start is every scpr's bussiness.

#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, PRStates::TSendParamsToServiceProvider, CoreNetStates::TAwaitingParamResponse, IpSCprStates::TNoTagOrAlreadyStarted)

#else

	NODEACTIVITY_ENTRY(CoreNetStates::KBearerPresent, IpSCprStates::TSendParamsToServiceProvider, CoreNetStates::TAwaitingParamResponse, IpSCprStates::TNoTagOrAlreadyStarted)

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TStartServiceProviderRetry, CoreNetStates::TAwaitingStarted, MeshMachine::TNoTag)

    NODEACTIVITY_ENTRY(CoreNetStates::KAlreadyStarted,CoreNetStates::TSendApplyRequest, TAwaitingApplyResponseOrError, MeshMachine::TNoTagOrErrorTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendStarted)

	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TRaiseActivityError)

NODEACTIVITY_END()

}

namespace IPSCprActivities

{

DECLARE_DEFINE_ACTIVITY_MAP(activityMap)

    ACTIVITY_MAP_ENTRY(IPSCprAddressUpdate, IPSCprAddressUpdate)

    ACTIVITY_MAP_ENTRY(IPSCprApplyRequest, IpSCprApplyReq)

    ACTIVITY_MAP_ENTRY(IPSCprStartActivity, IPSCprStart)

#ifndef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

	ACTIVITY_MAP_ENTRY(IPSCprParamsRequest, IPSCprSetParams)

#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

ACTIVITY_MAP_END_BASE(IPDeftBaseSCprActivities, ipdeftbasescprActivityMap)

}

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

//

// CIpSubConnectionProvider methods

//

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

CIpSubConnectionProvider* CIpSubConnectionProvider::NewL(CIpSubConnectionProviderFactory& aFactory)

/**

Construct a new IP SubConnection Provider Object

@params aFactory factory that create this object

@param aConnProvider Connection Provider associated with this object

*/

	{

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::NewL")));

	CIpSubConnectionProvider* self = new (ELeave) CIpSubConnectionProvider(aFactory);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

	return self;

	}

CIpSubConnectionProvider::~CIpSubConnectionProvider()

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::~CIpSubConnectionProvider [%08x]"), this));

    LOG_NODE_DESTROY(KIPSCprTag, CIpSubConnectionProvider);

    }

CIpSubConnectionProvider::CIpSubConnectionProvider(ESock::CSubConnectionProviderFactoryBase& aFactory)

:CIpSubConnectionProviderBase(aFactory, IPSCprActivities::activityMap::Self())

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::CIpSubConnectionProvider [%08x]"), this));

    LOG_NODE_CREATE(KIPSCprTag, CIpSubConnectionProvider);

    }

void CIpSubConnectionProvider::ConstructL()

/**

IP SubConnection Provider Second Phase Constructor

*/

	{

    CIpSubConnectionProviderBase::ConstructL(KIPSCPRPreallocatedActivityBufferSize);

	}

RNodeInterface* CIpSubConnectionProvider::NewClientInterfaceL(const TClientType& aClientType, TAny* /*aClientInfo*/)

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::NewClientInterfaceL [%08x]"), this));

    if (aClientType.Type() & TCFClientType::EData)

        {

        return new (ELeave) RIPDataClientNodeInterface();

        }

    return CCoreSubConnectionProvider::NewClientInterfaceL(aClientType);

    }

void CIpSubConnectionProvider::Received(TNodeContextBase& aContext)

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::Received [%08x]"), this));

    Messages::TNodeSignal::TMessageId noPeerIds[] = {

        TCFFactory::TPeerFoundOrCreated::Id(),

        TCFPeer::TJoinRequest::Id(),

        Messages::TNodeSignal::TMessageId()

        };

    MeshMachine::AMMNodeBase::Received(noPeerIds, aContext);

	MeshMachine::AMMNodeBase::PostReceived(aContext);

	}

void CIpSubConnectionProvider::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)

    {

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::ReceivedL [%08x]"), this));

	ESOCK_DEBUG_MESSAGE_INTERCEPT(aSender, aMessage, aRecipient);

	IpSCprStates::TContext ctx(*this, aMessage, aSender, aRecipient);

    CIpSubConnectionProvider::Received(ctx);

    User::LeaveIfError(ctx.iReturn);

	}

TInt CIpSubConnectionProvider::AddressCompletionValidation(RIPDataClientNodeInterface& aDataClient)

/**

Helper function to check for presence of source  and destionation address in DataClient Node Interface

@param aDataClient Data Client

*/

	{

	__IPCPRLOG(IpCprLog::Printf(_L("CIpSubConnectionProvider::AddressCompletionValidation [%08x]"), this));

	TUint addrFamily = aDataClient.iCliSrcAddr.Family();

	if( addrFamily != KAfInet6 && addrFamily != KAfInet)

		{

		__IPCPRLOG(IpCprLog::Printf(_L("Source Address not defined")));

		return KErrNotReady;

		}

	addrFamily = aDataClient.iCliSrcAddr.Family();

	if( addrFamily != KAfInet6 && addrFamily != KAfInet)

		{

		__IPCPRLOG(IpCprLog::Printf(_L("Destination Address not defined")));

		return KErrNotReady;

		}

	return KErrNone;

	}

CSubConIPAddressInfoParamSet* CIpSubConnectionProvider::InitBundleL()

/**

Helper function to initialize param bundle

*/

	{

	CSubConIPAddressInfoParamSet* retValue(NULL);

	// create family

	RCFParameterFamilyBundleC& bundle = GetOrCreateParameterBundleL();

	RParameterFamily family=bundle.FindFamily(KSubConIPAddressInfoFamily);

	if ( family.IsNull() ) 

		{

		__IPCPRLOG(IpCprLog::Printf(_L("SubConIPAddressInfoFamily is created")));

		//family = bundle.CreateFamilyL(KSubConIPAddressInfoFamily); //PJLEFT

		RCFParameterFamilyBundle newBundle;

		newBundle.CreateL();

		newBundle.Open(iParameterBundle);

		family = newBundle.CreateFamilyL(KSubConIPAddressInfoFamily);

		retValue = CSubConIPAddressInfoParamSet::NewL(family, RParameterFamily::ERequested);

		newBundle.Close();

		}

	else

		{

		// get param set

		STypeId typeId = STypeId::CreateSTypeId( CSubConIPAddressInfoParamSet::EUid,

						CSubConIPAddressInfoParamSet::ETypeId );

		retValue = static_cast<CSubConIPAddressInfoParamSet*>

			(family.FindParameterSet(typeId,RParameterFamily::ERequested));

		}

	return retValue;

	}