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

// ESock Sub Session Activities

// THIS API IS INTERNAL TO NETWORKING AND IS SUBJECT TO CHANGE AND NOT FOR EXTERNAL USE

//

//

/**

 @file

 @internalComponent

*/

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_nodemessages.h>

#include <ss_std.h>

#include <comms-infras/ss_esockstates.h>

#include "ss_esockactivities.h"

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockCrStaESclAC, "ESockCrStaESclAC");

#endif

#if defined LOG || defined ESOCK_EXTLOG_ACTIVE

	#define KESockActivityTag KESockCoreProviderTag

	_LIT8(KESockActivitySubTag, "esockactivity");

#endif

using namespace NetStateMachine;

using namespace SubSessStates;

using namespace SubSessActivities;

using namespace MeshMachine;

using namespace ESock;

//

//CESockClientActivityBase

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

	{

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

	}

CESockClientActivityBase::~CESockClientActivityBase()

	{

	if (!iMessage.IsNull())

		{ //Can be NULL only if the client has been panicked and we do not want to complete it

		__ASSERT_DEBUG(iSubSession, User::Panic(KSpecAssert_ESockCrStaESclAC, 1));

		LOG(ESockLogExternal::Printf(KESockActivityTag, KESockActivitySubTag, _L8("~CESockClientActivityBase %08x:\tRMessage2::Complete (%08x) with %d."), this, iMessage.Handle(), Error()));

		iMessage.Complete(Error());

		}

	SetError(KErrNone);

	}

void CESockClientActivityBase::StartL(TNodeContextBase& aContext, const Messages::XNodePeerId& aOriginator, const TStateTriple& aFirst)

	{

	//We should not be starting when the close activity is running!

	__ASSERT_DEBUG(ActivityId()==ECFActivityDestroy || aContext.iNode.CountActivities(ECFActivityDestroy)==0, User::Panic(KSpecAssert_ESockCrStaESclAC, 2));

	//Very important for client activities is to allow only one outstanding request at a time.

	//This is achieved by allowing only the first originator to start such activity

	if (iOriginators.Count())

		{

		MESH_LOG_CONTEXT_EXT(KESockMeshMachine, aContext, _L8("ERROR: CESockClientActivityBase::StartL->One outstanding request allowed"));

		User::Leave(KErrInUse);

		}

	//Either we are the close activity or there can not be close running when this activity is started

	__ASSERT_DEBUG(ActivitySigId()==ECFActivityDestroy || aContext.iNode.CountActivities(ECFActivityDestroy)==0, User::Panic(KSpecAssert_ESockCrStaESclAC, 3));

  	iOriginators.AppendL(aOriginator);

	MESH_LOG_ACTIVITY_EXT(KESockMeshMachine, this, &aContext, (_L8("CESockClientActivityBase %08x:\tStartL->starting activity"), this));

	__ASSERT_DEBUG(IsIdle(), User::Panic(KSpecAssert_ESockCrStaESclAC, 4));

	NetStateMachine::ACore::Start(&aContext, aFirst);

	MESH_LOG_ACTIVITY_EXT(KESockMeshMachine, this, &aContext, (_L8("CESockClientActivityBase %08x:\tStartL->activity started"), this));

	}

void CESockClientActivityBase::AcquireOwnership(RMessage2& aMessage, CSockSubSession& aSubSession)

	{

	__ASSERT_DEBUG(iMessage.IsNull(), User::Panic(KSpecAssert_ESockCrStaESclAC, 5));

	__ASSERT_DEBUG(!iSubSession, User::Panic(KSpecAssert_ESockCrStaESclAC, 6));

	iMessage = aMessage;

	aMessage = RMessage2(); //Null the original message

	iSubSession = &aSubSession;

	LOG(ESockLogExternal::Printf(KESockActivityTag, KESockActivitySubTag, _L8("CESockClientActivityBase %08x:\tRMessage2 ownership taken! RMessage2(%08x), SubSession(%08x), ActivityId(%d)"), this, iMessage.Handle(), &aSubSession, ActivityId()));

	aSubSession.DontCompleteCurrentRequest();

	}

void CESockClientActivityBase::PanicClient(TESockPanic aPanic)

	{

	__ASSERT_DEBUG(!iMessage.IsNull(), User::Panic(KSpecAssert_ESockCrStaESclAC, 7));

	__ASSERT_DEBUG(iSubSession, User::Panic(KSpecAssert_ESockCrStaESclAC, 8));

	RThread t;

	iMessage.Client(t);

	TExitType exittype=t.ExitType();

	t.Close();

	if(exittype == EExitPending) // is client alive?

		{

		LOG(ESockLogExternal::Printf(KESockActivityTag, KESockActivitySubTag, _L8("CESockClientActivityBase::PanicClient\tRMessage2(%08x), Reason=%d"), iMessage.Handle(), aPanic));

		iMessage.Panic(KESockClientPanic, aPanic);

		}

	iMessage = RMessage2(); //Clear the message so that it does not get completed

	iSubSession = NULL;

	}

void CESockClientActivityBase::ReadL(TInt aSrcParamIndex, TDes8& aDes)

	{

	__ASSERT_DEBUG(!iMessage.IsNull(), User::Panic(KSpecAssert_ESockCrStaESclAC, 9)); //Read only after it has been initialised!

	TInt err = iMessage.Read(aSrcParamIndex, aDes);

	if (err!=KErrNone)

		{

		PanicClient(ESockBadHandle);

		User::Leave(err);

		}

	}

TInt CESockClientActivityBase::GetDesLengthL(TInt aSrcParamIndex)

	{

 	__ASSERT_DEBUG(!iMessage.IsNull(), User::Panic(KSpecAssert_ESockCrStaESclAC, 10));

 	return iMessage.GetDesLengthL(aSrcParamIndex);

	}

TInt CESockClientActivityBase::GetDesMaxLengthL(TInt aSrcParamIndex)

	{

 	__ASSERT_DEBUG(!iMessage.IsNull(), User::Panic(KSpecAssert_ESockCrStaESclAC, 11));

 	return iMessage.GetDesMaxLengthL(aSrcParamIndex);

	}

void CESockClientActivityBase::WriteL(TInt aSrcParamIndex, TDes8& aDes)

	{

	iMessage.WriteL(aSrcParamIndex,aDes);

	}

TInt CESockClientActivityBase::Function()

	{

	return iMessage.Function();

	}

void CESockClientActivityBase::HasCapabilityL(TCapability aCapability, const char* aDiagnosticMessage)

    {

    return iMessage.HasCapabilityL(aCapability, aDiagnosticMessage);

    }

//

//CPreallocatedESockClientActivity

MeshMachine::CNodeActivityBase* CPreallocatedESockClientActivity::New(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)

	{

	TAny* space = BorrowPreallocatedSpace(aNode, sizeof(CPreallocatedESockClientActivity));

	CPreallocatedESockClientActivity* self = new (space) CPreallocatedESockClientActivity(aActivitySig, aNode);

	self->InsertPreallocatedDestroyActivity();

	return self;

	}

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

:	CESockClientActivityBase(aActivitySig,aNode),

	APreallocatedOriginators<1>(iOriginators)

	{

	}

void CPreallocatedESockClientActivity::Destroy()

	{

	ReturnPreallocatedSpace(this);

	this->~CPreallocatedESockClientActivity(); //Run the destructor

	}

//

//CCloseActivity

MeshMachine::CNodeActivityBase* CCloseActivity::New(const MeshMachine::TNodeActivity& aActivitySig, MeshMachine::AMMNodeBase& aNode)

	{

	TAny* space = BorrowPreallocatedSpace(aNode, sizeof(CCloseActivity));

	CCloseActivity* self = new (space) CCloseActivity(aActivitySig, aNode);

	self->InsertPreallocatedDestroyActivity();

	return self;

	}

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

:	CESockClientActivityBase(aActivitySig,aNode),

	APreallocatedOriginators<1>(iOriginators)

	{

	}

void CCloseActivity::Destroy()

	{

	ReturnPreallocatedSpace(this);

	this->~CCloseActivity(); //Run the destructor

	ESock::CMMSockSubSession* subSessNode = static_cast<ESock::CMMSockSubSession*>(&iNode);

	delete subSessNode; //We are taking down the whole node. All relevant diagnostics and logging is done from MeshMachine::AMMNodeBase::~MeshMachine::AMMNodeBase().

	}