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

// PDP SubConnection Provider states/transitions

// 

//

/**

 @file

 @internalComponent

*/

#include <comms-infras/es_config.h>

#include <comms-infras/corescpractivities.h>

#include <comms-infras/ss_mcprnodemessages.h>

#include "PDPSCPRStates.h"

#include "PDPDeftSCPR.h"

#include "PDPParamMapper.h"

#include <comms-infras/ss_log.h>

#include <networking/ipaddrinfoparams.h>

#include <networking/mbmsparams.h>

#include <ip_subconparams.h>

#include <genericscprparams.h>

#include "pdpfsmnmspace.h"

#include "pdpdef.h"

#include <comms-infras/ss_nodemessages_flow.h>

#include <comms-infras/ss_nodemessages.h>

#include <comms-infras/ss_api_ext.h>

#include <elements/nm_messages_errorrecovery.h>

#include <comms-infras/sockmes.h> // for ioctl ipc

#include <nifvar_internal.h>

#include <elements/mm_activities.h>

using namespace Messages;

using namespace MeshMachine;

using namespace ESock;

using namespace NetStateMachine;

using namespace PDPSCprActivities;

using namespace SpudMan;

using namespace ConnectionServ;

#ifdef _DEBUG

_LIT (KPdpSCprPanic,"PpdScprPanic");

#endif

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

//

// States

//

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

namespace PDPSCprStates

{

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

//Util

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

DEFINE_SMELEMENT(TAwaitingPDPFSMMessage, NetStateMachine::MState, PDPSCprStates::TContext)

TBool TAwaitingPDPFSMMessage::Accept()

    {

    return iContext.iMessage.IsMessage<TPDPFSMMessages::TPDPFSMMessage>();

    }

DEFINE_SMELEMENT(TNoTagOrError, NetStateMachine::MStateFork, PDPSCprStates::TContext)

TInt TNoTagOrError::TransitionTag()

    {

    ASSERT(iContext.iNodeActivity);

    TPDPFSMMessages::TPDPFSMMessage& msg = message_cast<TPDPFSMMessages::TPDPFSMMessage>(iContext.iMessage);

    if (msg.iValue2 != KErrNone)

        {

        iContext.iNodeActivity->SetError(msg.iValue2);

        return KErrorTag;

        }

    return KNoTag;

    }

DEFINE_SMELEMENT(TNoTagOrAlreadyStarted, NetStateMachine::MStateFork, PDPSCprStates::TContext)

TInt TNoTagOrAlreadyStarted::TransitionTag()

    {

    ASSERT(iContext.iMessage.IsMessage<TCFDataClient::TStart>());

    ASSERT(iContext.iNodeActivity);

    if (iContext.Node().iPDPFsmContextId != CPDPSubConnectionProvider::EInvalidContextId)

        {

        return CoreNetStates::KAlreadyStarted;

        }

    return KNoTag;

    }

TBool TAwaitingPDPFSMMessage::Accept(TInt aExtensionId)

    {

    TPDPFSMMessages::TPDPFSMMessage* pdpmsg = message_cast<TPDPFSMMessages::TPDPFSMMessage>(&iContext.iMessage);

    if ( pdpmsg )

        {

        if (pdpmsg->iValue1 == aExtensionId)

            {

            return ETrue;

            }

        }

    return EFalse;

    }

DEFINE_SMELEMENT(TSendDataClientIdleIfNoSubconnsAndNoClients, NetStateMachine::MStateTransition, PDPSCprStates::TDefContext)

void TSendDataClientIdleIfNoSubconnsAndNoClients::DoL()

    {

	iContext.Node().SendDataClientIdleIfNoSubconnsAndNoClientsL();

	}

DEFINE_SMELEMENT(TNoTagOrSendErrorRecoveryRequestOrError, NetStateMachine::MStateFork, PDPSCprStates::TContext)

TInt TNoTagOrSendErrorRecoveryRequestOrError::TransitionTag()

	{

	ASSERT(iContext.iNodeActivity);

	TPDPFSMMessages::TPDPFSMMessage& msg = message_cast<TPDPFSMMessages::TPDPFSMMessage>(iContext.iMessage);

	if (msg.iValue2 == KErrUmtsMaxNumOfContextExceededByNetwork ||

	    msg.iValue2 == KErrUmtsMaxNumOfContextExceededByPhone)

		{

		return KSendErrorRecoveryRequest;

		}

	else if (msg.iValue2 != KErrNone)

		{

		iContext.iNodeActivity->SetError(msg.iValue2);

		return KErrorTag;

		}

	return KNoTag;

	}

DEFINE_SMELEMENT(TNoTagBackwardOrErrorTag, NetStateMachine::MStateFork, PDPSCprStates::TContext)

TInt TNoTagBackwardOrErrorTag::TransitionTag()

	{

	__ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KPdpSCprPanic, CorePanics::KPanicNoActivity));

	iContext.Node().SetContentionRequested(EFalse);

	if (iContext.iMessage.IsMessage<TEErrorRecovery::TErrorRecoveryResponse>() &&

		message_cast<TEErrorRecovery::TErrorRecoveryResponse>(iContext.iMessage).iErrResponse.iAction == TErrResponse::ERetry)

		{

		return KNoTag | NetStateMachine::EBackward;	

		}

	TEErrorRecovery::TErrorRecoveryResponse* recoveryMsg = message_cast<TEErrorRecovery::TErrorRecoveryResponse>(&iContext.iMessage);

	if (recoveryMsg)

		{

		iContext.iNodeActivity->SetError(recoveryMsg->iErrResponse.iError);

		}

	TEBase::TError* errMsg = message_cast<TEBase::TError>(&iContext.iMessage);

	if (errMsg)

		{

		iContext.iNodeActivity->SetError(errMsg->iValue);

		}

	return KErrorTag;

	}

DEFINE_SMELEMENT(TNoTagOrContentionTag, NetStateMachine::MStateFork, PDPSCprStates::TContext)

TInt TNoTagOrContentionTag::TransitionTag()

	{

	if (iContext.Node().ContentionRequested())

		{

		return KContentionTag;

		}

	return KNoTag;

	}

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

//Provisioning

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

DEFINE_SMELEMENT(TSelfInit, NetStateMachine::MStateTransition, PDPSCprStates::TContext)

void TSelfInit::DoL()

    {

        {

        //Non-default SCPR running this code

        ASSERT(iContext.Node().ControlProvider());

        ESock::TDefaultSCPRFactoryQuery query(iContext.Node().ControlProvider()->RecipientId(), TSubConnOpen::EAttachToDefault );

        ESock::CSubConnectionProviderBase* defProvider = static_cast<ESock::CSubConnectionProviderBase*>(static_cast<ESock::CSubConnectionProviderFactoryBase&>(iContext.Node().Factory()).Find(query));

        ASSERT(defProvider);

        iContext.Node().iDefaultSCPR = static_cast<CPDPDefaultSubConnectionProvider*>(defProvider);

        ASSERT(iContext.Node().iDefaultSCPR != &iContext.Node()); //This transition is not expected to be executed for defaults.

        ASSERT(iContext.Node().iDefaultSCPR->iPdpFsmInterface != NULL);

        ASSERT(iContext.Node().iPdpFsmInterface == NULL);

        iContext.Node().iPdpFsmInterface = iContext.Node().iDefaultSCPR->iPdpFsmInterface;

        iContext.Node().iPdpFsmInterface->Open();

        }

    else

        {

        if (tsyProvision == NULL)

        	{

        	User::Leave(KErrCorrupt);

        	}

        CGPRSProvision* gprsProvision = const_cast<CGPRSProvision*>(static_cast<const CGPRSProvision*>(

        if (gprsProvision == NULL)

        	{

        	case TPacketDataConfigBase::KConfigGPRS:

        		break;

        	case TPacketDataConfigBase::KConfigRel99Rel4:

        		break;

        	case TPacketDataConfigBase::KConfigRel5:

        		break;

        	default:

        		User::Leave(KErrNotSupported);

        	}

        }

    }

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

//Creating context

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

MeshMachine::CNodeActivityBase* CStartActivity::NewL( const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode )

    {

    return new (ELeave) CStartActivity(aActivitySig, aNode);

    };

CStartActivity::~CStartActivity()

    {

    RNodeInterface* startedDataClient = iNode.GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EData, TCFClientType::EStarted));

    ASSERT(iNode.GetClientIter<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EData))[1] == NULL);

    CPDPSubConnectionProvider& pdpscpr = static_cast<CPDPSubConnectionProvider&>(iNode);

    if (pdpscpr.iPDPFsmContextId == CPDPSubConnectionProvider::EInvalidContextId ||

        startedDataClient == NULL)

        {

        pdpscpr.LinkDown(Error());

        }

    }

CStartActivity::CStartActivity( const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)

:MeshMachine::CNodeRetryActivity(aActivitySig, aNode)

    {

    }

DEFINE_SMELEMENT(TCreateSecondaryOrMbmsPDPCtx, NetStateMachine::MStateTransition, PDPSCprStates::TContext)

void TCreateSecondaryOrMbmsPDPCtx::DoL()

    {

    ASSERT(iContext.Node().iPdpFsmInterface);

  	RParameterFamily mbmsInfoFamily = iContext.Node().iParameterBundle.FindFamily(KSubConChannelParamsType);

  	STypeId typeId = STypeId::CreateSTypeId(KSubConChannelParamsImplUid, KSubConChannelParamsType);

    CSubConChannelParamSet *mbmsSubConParamSet = mbmsInfoFamily.IsNull() ? NULL :

    		(CSubConChannelParamSet *)(mbmsInfoFamily.FindParameterSet(typeId, RParameterFamily::ERequested));

    if (mbmsSubConParamSet)

		{

		RPacketMbmsContext::TContextConfigMbmsV1 mbmsConfig;

		ConnectionServ::TMBMSChannelInfoV1* channelPtr = reinterpret_cast<ConnectionServ::TMBMSChannelInfoV1*>(mbmsSubConParamSet->GetChannelInfo());

   		mbmsConfig.iTmgi		 		= channelPtr->GetTmgi();

   	 	mbmsConfig.iMbmsServicePriority = channelPtr->GetServicePriority();

   		mbmsConfig.iMbmsAccessBearer    = channelPtr->GetScope();

   		TSessionOperatioInfo sessionInfo;

		CSubConMBMSExtensionParamSet *mbmsSessionSet=static_cast<CSubConMBMSExtensionParamSet *>(mbmsInfoFamily.FindParameterSet(

			STypeId::CreateSTypeId(KSubConMBMSExtParamsImplUid,KSubConMBMSSessionExtParamsType),RParameterFamily::ERequested));

		if (mbmsSessionSet)

			{

			sessionInfo.iSessionIds.Reset();

			for(TInt i=0;i<mbmsSessionSet->GetSessionCount();i++)

				{

				sessionInfo.iSessionIds.Append(mbmsSessionSet->GetSessionId(i));

				}

			sessionInfo.iOperation = mbmsSessionSet->GetOperationType();

			mbmsConfig.iMbmsServiceMode  = mbmsSessionSet->GetServiceMode();

			}

		else

			{

			User::Leave(KErrCorrupt);

			}

		iContext.Node().iPDPFsmContextId = iContext.Node().iPdpFsmInterface->NewFsmContextL(iContext.Node(),SpudMan::EMbms);

		iContext.Node().iContextType=SpudMan::EMbms;

       	iContext.Node().iPdpFsmInterface->Set(iContext.Node().iPDPFsmContextId,mbmsConfig);

		TTFTInfo tft;

    	User::LeaveIfError(iContext.Node().iPdpFsmInterface->Set(iContext.Node().iPDPFsmContextId, tft));

    	User::LeaveIfError(iContext.Node().iPdpFsmInterface->Set(iContext.Node().iPDPFsmContextId, sessionInfo));

    	User::LeaveIfError(iContext.Node().iPdpFsmInterface->Input(iContext.Node().iPDPFsmContextId, SpudMan::ECreateMbmsPDPContext));

    	iContext.Node().iActivityAwaitingResponse = iContext.iNodeActivity->ActivityId();

    	sessionInfo.iSessionIds.Close();

    	}

	else

		{

		// Reset the default QoS and TFT here. KContextQoSSet should arrive soon

		// with the proper values.

#ifdef SYMBIAN_NETWORKING_UMTSR5

		RPacketQoS::TQoSR5Requested qos;

#else

		RPacketQoS::TQoSR99_R4Requested qos;

#endif

		// SYMBIAN_NETWORKING_UMTSR5

		iContext.Node().iPDPFsmContextId = iContext.Node().iPdpFsmInterface->NewFsmContextL(iContext.Node(),SpudMan::ESecondary);

		iContext.Node().iContextType = SpudMan::ESecondary;

		User::LeaveIfError(iContext.Node().iPdpFsmInterface->Set(iContext.Node().iPDPFsmContextId,  qos));

		TTFTInfo tft;

		User::LeaveIfError(iContext.Node().iPdpFsmInterface->Set(iContext.Node().iPDPFsmContextId, tft));

		User::LeaveIfError(iContext.Node().iPdpFsmInterface->Input(iContext.Node().iPDPFsmContextId, SpudMan::ECreateSecondaryPDPContext));

		iContext.Node().iActivityAwaitingResponse = iContext.iNodeActivity->ActivityId();

		}

    }

DEFINE_SMELEMENT(TAwaitingPDPCtxCreated, NetStateMachine::MState, PDPSCprStates::TContext)

TBool TAwaitingPDPCtxCreated::Accept()

    {

    if (iContext.Node().iContextType != SpudMan::EMbms)

    	{

    	return TAwaitingPDPFSMMessage::Accept(KSecondaryContextCreated);

    	}

    else

    	{

       	return TAwaitingPDPFSMMessage::Accept(KMbmsContextCreated); //

		}

    }

DEFINE_SMELEMENT(TAwaitingPrimaryPDPCtxCreated, NetStateMachine::MState, PDPSCprStates::TContext)

TBool TAwaitingPrimaryPDPCtxCreated::Accept()

    {

    return TAwaitingPDPFSMMessage::Accept(KPrimaryContextCreated);

    }

DEFINE_SMELEMENT(TCreatePrimaryPDPCtx, NetStateMachine::MStateTransition, PDPSCprStates::TDefContext)

void TCreatePrimaryPDPCtx::SetupSipServerAddrRetrievalL(RPacketContext::TProtocolConfigOptionV2& aPco)

	{

	TPtr8 pcoPtr(const_cast<TUint8*>(aPco.iMiscBuffer.Ptr()),aPco.iMiscBuffer.Length(),aPco.iMiscBuffer.MaxLength());

	// attach TTlv to the buffer

	TTlvStruct<RPacketContext::TPcoId,RPacketContext::TPcoItemDataLength> tlv(pcoPtr,0);

	tlv.AppendItemL(RPacketContext::TPcoId(RPacketContext::EEtelPcktPCSCFAddressRequest),

		TPtr8(static_cast<TUint8*>(NULL), 0, 0));

	aPco.iMiscBuffer.SetLength(pcoPtr.Length());

	}

void TCreatePrimaryPDPCtx::SetImsSignallingFlagL(RPacketContext::TProtocolConfigOptionV2& aPco, TBool aImcn)

	{

	if (aImcn)

		{

		TPtr8 pcoPtr(const_cast<TUint8*>(aPco.iMiscBuffer.Ptr()),aPco.iMiscBuffer.Length(),aPco.iMiscBuffer.MaxLength());

		TTlvStruct<RPacketContext::TPcoId,RPacketContext::TPcoItemDataLength> tlv(pcoPtr,0);

		tlv.AppendItemL(RPacketContext::TPcoId(RPacketContext::EEtelPcktIMCNMSSubsystemSignallingFlag ),

						TPtr8(static_cast<TUint8*>(NULL), 0, 0));

		aPco.iMiscBuffer.SetLength(pcoPtr.Length());

		}

	}

TBool TCreatePrimaryPDPCtx::IsModeGsmL() const

	{

    const CTSYProvision* tsyProvision = static_cast<const CTSYProvision*>(

    	iContext.Node().AccessPointConfig().FindExtension(CTSYProvision::TypeId()));

	if (tsyProvision == NULL)

		{

		User::Leave(KErrCorrupt);

		}

	RTelServer telServer;

	User::LeaveIfError(telServer.Connect());

	CleanupClosePushL(telServer);

	User::LeaveIfError(telServer.LoadPhoneModule(tsyProvision->iTsyName));

	TInt phones = 0;

	User::LeaveIfError(telServer.EnumeratePhones(phones));

	RTelServer::TPhoneInfo phoneInfo;

	TBuf<KCommsDbSvrMaxFieldLength> currentTsyName;

	TBool found = EFalse;

	_LIT(KTsyNameExtension, ".tsy");

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

		{

		User::LeaveIfError(telServer.GetTsyName(i, currentTsyName));

		// remove .TSY extension if necessary

		if (currentTsyName.Right(4).CompareF(KTsyNameExtension()) == 0)

			{

			currentTsyName = currentTsyName.Left(currentTsyName.Length() - 4);

			}

		// compare current TSY name with the one we're looking for

		if (currentTsyName.CompareF(tsyProvision->iTsyName) == 0)

			{

			// get phone info from the TSY

			User::LeaveIfError(telServer.GetPhoneInfo(i, phoneInfo));

			found = ETrue;

			break;

			}

		}

	if (!found)

		{

		User::Leave(KErrNotFound);

		}

	RMobilePhone phone;

	User::LeaveIfError(phone.Open(telServer, phoneInfo.iName));

	CleanupClosePushL(phone);

	RMobilePhone::TMobilePhoneNetworkMode networkMode = RMobilePhone::ENetworkModeUnknown;

	User::LeaveIfError(phone.GetCurrentMode(networkMode));

	CleanupStack::PopAndDestroy(2); // phone, telServer

	return (networkMode == RMobilePhone::ENetworkModeGsm);

	}

void TCreatePrimaryPDPCtx::DoL()

    {

    iContext.Node().PostToClients<TDefaultClientMatchPolicy>(

            iContext.NodeId(),

            TCFMessage::TStateChange(

                    Elements::TStateChange(KPsdStartingConfiguration, KErrNone)).CRef(),

            TClientType(TCFClientType::ECtrlProvider));

	CGPRSProvision* gprsProvision = const_cast<CGPRSProvision*>(static_cast<const CGPRSProvision*>(

	    iContext.Node().AccessPointConfig().FindExtension(STypeId::CreateSTypeId(CGPRSProvision::EUid,CGPRSProvision::ETypeId))));

	//retrieve QoS (should be provisioned, but can also be overriden with SetParams).

	RPacketQoS::TQoSR5Requested qosOverridenParams;

	const RPacketQoS::TQoSR5Requested* qosParams = NULL;

	if (! iContext.Node().iParameterBundle.IsNull() && ! iContext.Node().iParameterBundle.FindFamily(KSubConQoSFamily).IsNull())

    	{

    	MPDPParamMapper::MapQosParamBundleToEtelL(iContext.Node().iParameterBundle, qosOverridenParams);

    	qosParams = &qosOverridenParams;

    	}

	else

    	{

    	const CDefaultPacketQoSProvision* defaultQoSProvision = static_cast<const CDefaultPacketQoSProvision*>(

    	    iContext.Node().AccessPointConfig().FindExtension(STypeId::CreateSTypeId(CDefaultPacketQoSProvision::EUid,CDefaultPacketQoSProvision::ETypeId)));

    	qosParams = defaultQoSProvision ? &defaultQoSProvision->iParams : NULL;

        //Here we're taking the qos defaults from the provision info, hence skipping the iParameterBundle.

        //The lack of iParameterBundle however and the respective ERequested params is badly tolerated by the rest

        //of the code (e.g.: when subsequently raising granted params it is assumed something has been requested).

        //Let's create a phoney requested params.

        //iContext.Node().CreateParameterBundleL();

		//RParameterFamily family = iContext.Node().iParameterBundle.CreateFamilyL(KSubConQoSFamily); //PJLEFT

		RCFParameterFamilyBundle newBundle;

		newBundle.CreateL();

		iContext.Node().iParameterBundle.Open(newBundle);

		RParameterFamily family = newBundle.CreateFamilyL(KSubConQoSFamily);

		CSubConQosGenericParamSet::NewL(family, RParameterFamily::ERequested);

    	}

	TTFTInfo tft; //We'll use empty/thus default TFT

	if (gprsProvision == NULL || qosParams == NULL)

    	{

    	User::Leave(KErrCorrupt);

    	}

	const CImsExtProvision* imsprov = static_cast<const CImsExtProvision*>(

		iContext.Node().AccessPointConfig().FindExtension(STypeId::CreateSTypeId(CImsExtProvision::EUid, CImsExtProvision::ETypeId)));

	switch (gprsProvision->UmtsGprsRelease())

			{

	    	case TPacketDataConfigBase::KConfigGPRS:

				{

				SetImsSignallingFlagL(gprsProvision->GetScratchContextAs<RPacketContext::TContextConfigGPRS>().iProtocolConfigOption, imsprov->iImsSignalIndicator);

				}

				break;

	    	case TPacketDataConfigBase::KConfigRel5:

		    case TPacketDataConfigBase::KConfigRel99Rel4:

				{

				SetImsSignallingFlagL(gprsProvision->GetScratchContextAs<RPacketContext::TContextConfigR99_R4>().iProtocolConfigOption, imsprov->iImsSignalIndicator);

				}

				break;

			}