// Copyright (c) 2007-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 Connection Provider activity definitions specific to User Prompt Service (UPS).

// 

//

/**

 @file

 @internalComponent

*/

#define SYMBIAN_NETWORKING_UPS

#ifdef SYMBIAN_NETWORKING_UPS

#include "ipcprups_activities.h"

#include <comms-infras/upsprstates.h>

#include <comms-infras/upsmessages.h>

#include <comms-infras/corecpractivities.h>

#include "ipcprups_states.h"

using namespace MeshMachine;

using namespace Messages;

using namespace UpsCprActivities;

using namespace ESock;

using namespace NetStateMachine;

using namespace IpCprActivities;

using namespace CprClientLeaveActivity;

namespace IpCprActivities

{

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityClientJoin, IpCprControlClientJoin, TNodeSignal::TNullMessageId, CIpCprCtrlClientJoinActivity::NewL) //May be waiting for both messages

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingControlClientJoin, IpCprStates::TNoTagOrUpsQueryOrAttachCapabilityQuery)

	// Non-UPS path

	THROUGH_NODEACTIVITY_ENTRY(IpCprStates::KAttachCapabilityQuery, IpCprStates::TCheckAttachCapabilities, TNoTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TAddControlClientAndSendJoinCompleteIfRequest, TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendDataClientActive)

	// UPS path.  Here if message was TCtrlClientJoinRequest and UPS Access Point Config extension was found.

	THROUGH_NODEACTIVITY_ENTRY(IpCprStates::KUpsQuery, CDeferredCtrlClientJoinActivity::TStoreControlClient, TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, CIpCprCtrlClientJoinActivity::TSendPolicyCheckRequest,

							UpsStates::TAwaitingPolicyCheckResponse, CIpCprCtrlClientJoinActivity::TNoTagOrUpsErrorTag)

	// UPS success.  A TPolicyCheckResponse was received with authorisation granted.

	LAST_NODEACTIVITY_ENTRY(KNoTag, CDeferredCtrlClientJoinActivity::TAddControlClientAndSendJoinComplete)

	// UPS error.  A TPolicyCheckResponse was received with authorisation denied.

	LAST_NODEACTIVITY_ENTRY(CIpCprCtrlClientJoinActivity::KUpsErrorTag, TDoNothing)

NODEACTIVITY_END()

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityPolicyCheckRequest, IpCprPolicyCheckRequest, UpsMessage::TPolicyCheckRequest, CNodeParallelActivityBase::NewL)

	// TODO: decide whether we should move some of these transitions/forks to the UpsCoreProviders

	FIRST_NODEACTIVITY_ENTRY(UpsStates::TAwaitingPolicyCheckRequest, IpCprStates::TNoTagOrUpsDisabledOrUpsEnabled)

	LAST_NODEACTIVITY_ENTRY(IpCprStates::KUpsDisabled, IpCprStates::TPostDisabledPolicyCheckResponseToOriginators)

	THROUGH_NODEACTIVITY_ENTRY(IpCprStates::KUpsEnabled, IpCprStates::TPopulatePolicyCheckRequest, TNoTag)

	NODEACTIVITY_ENTRY(KNoTag, UpsStates::TPostToControlProvider, UpsStates::TAwaitingPolicyCheckResponse, TNoTagOrErrorTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreStates::TPostToOriginators)

	LAST_NODEACTIVITY_ENTRY(KErrorTag, TDoNothing)

NODEACTIVITY_END()

DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityClientLeave, IpCprClientLeave, TNodeSignal::TNullMessageId, CClientLeaveActivity::NewL)

	FIRST_NODEACTIVITY_ENTRY(CoreStates::TAwaitingClientLeave, MeshMachine::TNoTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, IpCprStates::TSendUpsStatusChange, MeshMachine::TNoTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, CClientLeaveActivity::TRemoveClientAndDestroyOrphanedDataClients, CClientLeaveActivity::TNoTagOrSendPriorityToCtrlProvider)

	NODEACTIVITY_ENTRY(CprStates::KSendPriorityToCtrlProvider, CClientLeaveActivity::TUpdatePriorityForControlProvider, CoreStates::TAwaitingJoinComplete, CClientLeaveActivity::TNoTagOrSendPriorityToServProvider)

	NODEACTIVITY_ENTRY(CprStates::KSendPriorityToServProvider, CClientLeaveActivity::TUpdatePriorityForServiceProviders, CoreStates::TAwaitingJoinComplete, MeshMachine::TNoTag)

	THROUGH_NODEACTIVITY_ENTRY(KNoTag, CClientLeaveActivity::TSendLeaveCompleteAndSendDataClientIdleIfNeeded, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CprStates::TSendDataClientStatusStoppedIfNoControlClient)

NODEACTIVITY_END()

}

//

// CIpCprCtrlClientJoinActivity

//

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

	{

	TUint c = GetNextActivityCountL(aActivitySig, aNode);

	return new (ELeave) CIpCprCtrlClientJoinActivity(aActivitySig, aNode, c);

	}

CIpCprCtrlClientJoinActivity::CIpCprCtrlClientJoinActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TUint aNextActivityCount)

  : CIpCprUpsCtrlClientJoinActivity(aActivitySig, aNode, aNextActivityCount)

	{

	}

void CIpCprCtrlClientJoinActivity::GetPlatSecResultAndDestinationL(const ESock::MPlatsecApiExt& aPlatSecApi, TInt& aPlatSecResult, TUpsDestinationAddrType& aDestinationType, TDes8& aDestination) const

	{

   	aPlatSecResult = IpCprStates::CheckAttachPolicy(aPlatSecApi);	

	aDestination = KNullDesC8();

	aDestinationType = ETNone;

	}

//

// CIpCprUpsCtrlClientJoinActivity

//

CIpCprUpsCtrlClientJoinActivity::CIpCprUpsCtrlClientJoinActivity(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode, TUint aNextActivityCount)

  : CDeferredCtrlClientJoinActivity(aActivitySig, aNode, aNextActivityCount)

	{

	}

DEFINE_SMELEMENT(CIpCprUpsCtrlClientJoinActivity::TSendPolicyCheckRequest, NetStateMachine::MStateTransition, CIpCprUpsCtrlClientJoinActivity::TContext)

void CIpCprUpsCtrlClientJoinActivity::TSendPolicyCheckRequest::DoL()

/**

This transition is IPCPR specific because it applies the platsec check against NetworkServices,

and the TUpsDestinationAddr happens to be null for IP, but may not be for other technologies.

@TODO PREQ1116 - could we provision the technology specific information in a new APC structure,

as Viki suggests, and make this generic code ?  How would this be done ?  Can we template the code

against capability ?

*/

	{

	// Send TPolicyCheckRequest

    const MPlatsecApiExt* const platSecApi = reinterpret_cast<const MPlatsecApiExt*>(address_cast<TNodeId>(iContext.iSender).Node().FetchNodeInterfaceL(MPlatsecApiExt::KInterfaceId));

	// Retrieve process id and thread id

	TProcessId processId;

   	TThreadId threadId;

	User::LeaveIfError(platSecApi->GetProcessAndThreadId(processId, threadId));

	TInt policyCheckResult = KErrCorrupt;		// sanity - ensure it is overwritten

	TUpsDestinationAddr destination;

	TUpsDestinationAddrType destinationType;

	CIpCprUpsCtrlClientJoinActivity* act = iContext.Activity();

	act->GetPlatSecResultAndDestinationL(*platSecApi, policyCheckResult, destinationType, destination);

	// Retrieve policy check result

 	const CMMCommsProviderBase& node = iContext.Node();

	// Create a TPolicyCheckRequest message (with an empty destination name) and send to Control Provider.

	const TPolicyCheckRequestParams params(processId, threadId, policyCheckResult, destination, destinationType);

	const UpsMessage::TPolicyCheckRequest checkMsg(params);

	RNodeInterface* const ctrlProvider = node.ControlProvider();

	ASSERT(ctrlProvider);

	act->PostRequestTo(*ctrlProvider, checkMsg);

	}

DEFINE_SMELEMENT(CIpCprUpsCtrlClientJoinActivity::TNoTagOrUpsErrorTag, NetStateMachine::MStateFork, CIpCprCtrlClientJoinActivity::TContext)

TInt CIpCprUpsCtrlClientJoinActivity::TNoTagOrUpsErrorTag::TransitionTag()

/**

Return KNoTag if UPS was successful, else KUpsErrorTag.

Also sets the activity error which triggers cleanup in ~CReversibleCtrlClientJoinActivity.

@return KNoTag if a TPolicyCheckResponse was received with KErrNone, KErrorTag if a

TPolicyCheckResponse was received without KErrNone, KErrorTag if TError was received.

@TODO PREQ1116 - this is generic enough to be moved into CReversibleCtrlClientJoinActivity at least.

*/

	{		

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

	CNodeActivityBase* act = iContext.Activity();

	if (errMsg)

		{

		act->SetError(errMsg->iValue);

		return KUpsErrorTag;

		}

	const UpsMessage::TPolicyCheckResponse& msg = message_cast<UpsMessage::TPolicyCheckResponse>(iContext.iMessage);

	if (msg.iValue != KErrNone)

		{

		act->SetError(msg.iValue);

		return KUpsErrorTag;

		}

	return KNoTag;

	}

#endif //SYMBIAN_NETWORKING_UPS