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

#include <comms-infras/ss_tiermanagerutils.h>

#include <comms-infras/connectionsettings.h>

#include <hash.h>

#include <e32math.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

const TUint8 KGenericNifChallengeSize = 8;

const TUint KGenericNifIdLength = 1;

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

//

// States

//

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

namespace PDPSCprStates

{

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

//Util

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

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

TBool TAwaitingPDPFSMMessage::Accept()

    {

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

    }

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

TInt TNoTagOrError::TransitionTag()

    {

    ASSERT(iContext.iNodeActivity);

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

    if (msg.iValue2 != KErrNone)

        {

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

        return KErrorTag;

        }

    return KNoTag;

    }

DEFINE_SMELEMENT(TNoTagOrUserAuthenticateOrAlreadyStarted, NetStateMachine::MStateFork, PDPSCprStates::TDefContext)

TInt TNoTagOrUserAuthenticateOrAlreadyStarted::TransitionTag()

    {

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

    ASSERT(iContext.iNodeActivity);

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

        {

        return CoreNetStates::KAlreadyStarted;

        }

    if (iContext.Node().PromptForAuth())

        {

        return PDPSCprStates::KUserAuthenticate;

        }

    return KNoTag;

    }

TBool TAwaitingPDPFSMMessage::Accept(TInt aExtensionId)

    {

    TPDPMessages::TPDPFSMMessage* pdpmsg = message_cast<TPDPMessages::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);

	TPDPMessages::TPDPFSMMessage& msg = message_cast<TPDPMessages::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)

// This is should be revisited in future releases, basic idea is that information

// that can be modified should have a visibility that is to that node's

// level and not further (i.e. changes here will affect this connection

// only, not every connection that uses this MCPR)

//      MCPR - AccessPointConfig() contains information that is used by

//             all connections under that MCPR and is unchanging

//       CPR - Again for all connections under that CPR and is unchanging

//      SCPR - Connection specific information (i.e. can change and does change)

//        DC - No point - just reads information.

// Here we've moved basically all of the configuration information that was in

// the MCPR [that could be moved] this is because some of it changes / is overwritten

// with information that comes out of etel/modem.  This also has the added benefit of

// freeing up memory in cases where the connection is torn down but the MCPR lies 

// around for availability purposes.  In the future, this code (or something like it)

// should be moved into the PDP.CPR when it exists.

void TSelfInit::SetupProvisionCfgL(ESock::CCommsDatIapView* aIapView)

    {

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

    RMetaExtensionContainer mec;

    mec.Open(tNode.AccessPointConfig());

    CleanupClosePushL(mec);

    mec.AppendExtensionL(CIPConfig::NewFromGPRSOutLC(aIapView));

    CleanupStack::Pop();

    mec.AppendExtensionL(CBCAProvision::NewLC(aIapView));

    CleanupStack::Pop();

    mec.AppendExtensionL(CImsExtProvision::NewLC(aIapView));

    CleanupStack::Pop();

    CGPRSProvision* gprsProvision = CGPRSProvision::NewLC(aIapView);

    mec.AppendExtensionL(gprsProvision);

    CleanupStack::Pop(gprsProvision);

    //It's not legal for the qos defaults to be absent.

    CDefaultPacketQoSProvision* defaultQoS = NULL;

    TRAPD(ret, defaultQoS = CDefaultPacketQoSProvision::NewL(aIapView));   

    if ((KErrNone == ret) && defaultQoS)           

        {

        CleanupStack::PushL(defaultQoS);

        mec.AppendExtensionL(defaultQoS);

        CleanupStack::Pop(defaultQoS);

        }

    else

        {

        if (KErrNoMemory == ret)

            {

            User::Leave(KErrNoMemory);

            }

        else

            {

            User::Leave(KErrCorrupt);

            }          

        }    

    CRawIpAgentConfig* rawIpAgentConfig = CRawIpAgentConfig::NewLC(aIapView, &gprsProvision->GetScratchContextAs<TPacketDataConfigBase>());

    mec.AppendExtensionL(rawIpAgentConfig);

    CleanupStack::Pop();

    tNode.AccessPointConfig().Close();

    tNode.AccessPointConfig().Open(mec);

    CleanupStack::PopAndDestroy(&mec); 

    }

void TSelfInit::DoL()

    {

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

    const TProviderInfoExt* providerInfoExt = static_cast<const TProviderInfoExt*>(tNode.AccessPointConfig().FindExtension(

            STypeId::CreateSTypeId(TProviderInfoExt::EUid, TProviderInfoExt::ETypeId)));

    // this should always be here, however, a bit of defensive programming

    // never hurt..

    if (providerInfoExt == NULL)

        {

        User::Leave(KErrCorrupt);

        }

    CCommsDatIapView* iapView = CCommsDatIapView::NewLC(providerInfoExt->iProviderInfo.APId());

    TRAP(tNode.iProvisionFailure,SetupProvisionCfgL(iapView));

    // Don't want any failure here to be masked by successful configuration later on.

    // A leave here will not cause a roll back of the connection but it will show an

    // Error -> message in the SVG diagram.  The provision failure error code will 

    // cause the connection rollback.

    User::LeaveIfError(tNode.iProvisionFailure);

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

        TBool promptForAuth = EFalse;

        iapView->GetBool(KCDTIdWCDMAIfPromptForAuth | KCDTIdOutgoingGprsRecord, promptForAuth);

        //Default SCPR executing this code, so safe to cast.

        CPDPDefaultSubConnectionProvider &tempNode = static_cast<CPDPDefaultSubConnectionProvider&>(iContext.Node());

        tempNode.SetPromptForAuth(promptForAuth);        

        }

    CleanupStack::PopAndDestroy();          // CloseIapView();

    }

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

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

	{