// 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()

    {

    CPDPSubConnectionProvider &tNode = static_cast<CPDPSubConnectionProvider&>(iContext.Node());

    // if the FSM interface is null, this means that we're initializing a secondary context

    // as this code is common for both

    if (tNode.iPdpFsmInterface == NULL)

        {

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

        {

        //default SCPR running this code (i.e. primary context)

        const CTSYProvision* tsyProvision =\

                static_cast<const CTSYProvision*>(tNode.AccessPointConfig().FindExtension(CTSYProvision::TypeId()));

        if (tsyProvision == NULL)

        	{

            // we do not have to set provision failure here

            // as it was set in the base class constructor

            // svg will show the leave error code though

        	User::Leave(KErrCorrupt);

        	}

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

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

        if (gprsProvision == NULL)

            {

            tNode.iProvisionFailure = KErrCorrupt;

            User::Leave(KErrCorrupt);

            }

        TInt configType = TPacketDataConfigBase::KConfigGPRS;

        switch (gprsProvision->UmtsGprsRelease())

        	{

        	case TPacketDataConfigBase::KConfigGPRS:

        	    configType = TPacketDataConfigBase::KConfigGPRS;

        		break;

        	case TPacketDataConfigBase::KConfigRel99Rel4:

        	    configType = TPacketDataConfigBase::KConfigRel99Rel4;

        		break;

        	case TPacketDataConfigBase::KConfigRel5:

        	    configType = TPacketDataConfigBase::KConfigRel5;

        		break;

        	default:

        	    // we do not have to set provision failure here

        	    // as it was set in the base class constructor

        	    // svg will show the leave error code though

        		User::Leave(KErrNotSupported);

        		break;

        	}

        // a provisioning failure would be unrecoverable as this only happens

        // we cannot create memory, access etel or there is a configuration

        // problem - however, leaving with an error here does not stop the

        // sequence of events because the handler for provision config is not

        // expecting a response. if there is a failure then it will be errored in 

        // the next activity in the sequence, i.e. DataClientStart

        TRAP(tNode.iProvisionFailure,tNode.iPdpFsmInterface->NewL(tsyProvision->iTsyName,configType));

        tNode.iDefaultSCPR = static_cast<CPDPDefaultSubConnectionProvider*>(&tNode);

        }

    }

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

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

			{