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

//

/**

 @file

 @internalTechnology

 @released since v9.5

*/

#include <comms-infras/ss_log.h>

#include <ss_std.h>

#include <comms-infras/esockmessages.h>

#include <in_sock.h> //for KAfInet

#include <elements/factorynotify.h>

#include <ss_glob.h>

#include <comms-infras/ss_roles.h>

#include <es_enum.h>

#include "ss_connectionsession.h"

#include <comms-infras/es_connectionservermessages.h>

#include <comms-infras/ss_tiermanager.h>

#include "ss_apiext_messages.h"

#include <elements/nm_messages_child.h>

#include <comms-infras/ss_nodemessages_tiermanager.h>

#include <comms-infras/ss_nodemessages_factory.h>

#include <comms-infras/ss_nodemessages_tiermanagerfactory.h>

#include <comms-infras/es_connectionservparameterbundletrace.h>

#include <comms-infras/es_connectionservparameterbundletraceimpl.h> // include this once per dll

#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_ESockSSockscnctn, "ESockSSockscnctn");

#endif

using namespace ConnectionServ;

using namespace ESock;

using namespace Messages;

using namespace MeshMachine;

using namespace CommsDat;

//Panic codes

_LIT(KConnectionSessionPanic, "ConnectionSession");

enum TConnectionSessionPanic

	{

	EExpectedServiceProvider = 0,     //

    };

/**

Constructor

*/

CConnectionSession::CConnectionSession(TUidType aUid, Den::TSessionUniqueId aSessionUniqueId)

	: CWorkerSession(aUid, aSessionUniqueId)

	{

//    LOG_NODE_CREATE(KESockConnectionTag, CConnectionSession);

	}

/*static*/ CConnectionSession* CConnectionSession::NewL(TProcessId aProcessId, TUidType aUid, Den::TSessionUniqueId aSessionUniqueId)

	{

	CConnectionSession* self = new (ELeave) CConnectionSession(aUid, aSessionUniqueId);

	CleanupStack::PushL(self);

	self->ConstructL(aProcessId);

	CleanupStack::Pop(self);

	return self;

	}

CConnectionSession::~CConnectionSession()

	{

	// No handshaking code required - cancelling any outstanding requests was already performed by the client side

	//  which synchonously waited for everything to shut down before issuing the close on the session.

	// Best make sure though.. :-)

	__ASSERT_DEBUG(iStatusMessage.IsNull(), User::Panic(KSpecAssert_ESockSSockscnctn, 1));

	__ASSERT_DEBUG(!iStatusBundle, User::Panic(KSpecAssert_ESockSSockscnctn, 2));

	__ASSERT_DEBUG(!iNotificationActive, User::Panic(KSpecAssert_ESockSSockscnctn, 3));

	__ASSERT_DEBUG(iNotificationMessage.IsNull(), User::Panic(KSpecAssert_ESockSSockscnctn, 4));

	__ASSERT_DEBUG(iNotificationQueue.Count()==0, User::Panic(KSpecAssert_ESockSSockscnctn, 5));

	iNotificationQueue.Close();

	LeaveServiceProvider();

    LOG_NODE_DESTROY(KESockConnectionTag, CConnectionSession)

	}

TInt CConnectionSession::CheckPolicy(const TSecurityPolicy& aPolicy, const char *aDiagnostic)

/**

Check the security policy of a process.

Called from a socket or resolver provider to check whether the process conforms to the security policy passed as

argument.

@see MProvdSecurityChecker

*/

	{

	RProcess process;

	TInt ret = aPolicy.CheckPolicy(process, aDiagnostic) ? KErrNone : KErrPermissionDenied;

	process.Close();

	return ret;

	}

void CConnectionSession::CompleteMessage(const RMessage2& aMessage, TInt aResult)

	{

	__ASSERT_DEBUG(!aMessage.IsNull(), User::Panic(KSpecAssert_ESockSSockscnctn, 6));

	if(!aMessage.IsNull())

		{

		LOG(ESockLog::Printf(KESockSessDetailTag, _L8("CConnectionSession(%08x):\tCompleteMessage(%08x) with %d"), this, aMessage.Handle(), aResult) );

		aMessage.Complete(aResult);

		}

	__ASSERT_DEBUG(aMessage.IsNull(), User::Panic(KSpecAssert_ESockSSockscnctn, 7));

	}

/**

 Handle messages for this server.

 @param aMessage Standard IPC request from client side

*/

void CConnectionSession::ServiceL(const RMessage2& aMessage)

	{

	LOG(

		TBuf8<64> messName;

		ESockLog::ConnServIPCMessName((TConnectionServerMessage) aMessage.Function(), messName);

		ESockLog::Printf(KESockServerTag, _L8("CConnectionSession(%08x):\tServiceL, Message(%08x) [%S]"),

				this, aMessage.Handle(), &messName);

		);

	const Den::RSafeMessage& safeMessage(static_cast<const Den::RSafeMessage&>(aMessage));

    const TInt function = aMessage.Function();

	LOG_DETAILED( ESockLog::Printf(KESockConnectionTag, _L("CConnectionSession %08x:\tCommand %d"), this, aMessage.Function()) );

    /* Cases handled without a subsession */

	switch (function)

        {

		case ECMAttachToTierManager:

			StartAttachToTierManager(aMessage);

			break;

		case ECMAccessPointStatusQuery_DoThenGetResultOrSize:

			{

			const Messages::TNodeId& sp = ServiceProviderL();

			// ensure not already active. Should be guarded by client side code

            if (!iStatusMessage.IsNull())

                {

                CompleteMessage(aMessage, KErrInUse);

                return;

                }

			// unpack bundle

			TInt length = aMessage.GetDesLengthL(0);

			RBuf8 buffer;

			buffer.CreateL(length);

			CleanupClosePushL(buffer);

			aMessage.ReadL(0, buffer);

			CConnectionServParameterBundle* queryBundle = CConnectionServParameterBundle::LoadL(buffer);

			CleanupStack::PopAndDestroy(&buffer);

			CleanupStack::PushL(queryBundle);

			CRefCountOwnedParameterBundle* bundleOwner = new(ELeave)CRefCountOwnedParameterBundle(queryBundle);

			CleanupStack::Pop();

			bundleOwner->Open();

			CleanupClosePushL(*bundleOwner);

			// create and send message

			TNodeCtxId us(ETierStatusActivity, NodeId()); //We pretend to be a MM node :)

			// ownership of bundle travels with message

			RClientInterface::OpenPostMessageClose(us, sp,

				TCFTierStatusProvider::TTierStatusQuery(bundleOwner, &aMessage).CRef());

            CleanupStack::Pop();

			// remember client request

			iStatusMessage = aMessage;

			}

			break;

		case ECMAccessPointStatusQuery_GetResult:

			{

			if (!iStatusBundle)

			    {

			    CompleteMessage(aMessage, KErrNotReady);

			    return;

			    }

			CRefCountOwnedParameterBundle* bundleOwner = iStatusBundle;

			const CConnectionServParameterBundle& bundle = *static_cast<const CConnectionServParameterBundle*>(bundleOwner->PtrL());

			iStatusBundle = NULL;

			CleanupClosePushL(*bundleOwner);

			TInt length = bundle.Length();

			// we should only be calling this after a realloc on the client side.

			//  so there should be no way the bundle won't fit

			if (length > safeMessage.GetDesMaxLengthL(0))

			    {

			    CompleteMessage(aMessage, KErrOverflow);

			    CleanupStack::PopAndDestroy(bundleOwner);

			    return;

			    }

			RBuf8 buffer;

			buffer.CreateL(length);

			CleanupClosePushL(buffer);

			User::LeaveIfError(bundle.Store(buffer));

			aMessage.WriteL(0, buffer);

			CompleteMessage(aMessage, KErrNone);

			CleanupStack::PopAndDestroy(&buffer);

			CleanupStack::PopAndDestroy(bundleOwner);

			}

			break;

		case ECMAccessPointStatusQuery_Cancel:

			{

			// complete the original IPC

			if (iStatusMessage.IsNull())

			    {

			    // nothing to cancel

			    CompleteMessage(aMessage, KErrNone);

			    return;

			    }

			CompleteMessage(iStatusMessage, KErrCancel);

			// create and send message

			TNodeCtxId us(ETierStatusActivity, NodeId()); //Pretend to be a MM node

			__ASSERT_DEBUG(ServiceProvider()!=Messages::TNodeId::NullId(),User::Panic(KConnectionSessionPanic,EExpectedServiceProvider));

			RClientInterface::OpenPostMessageClose(us, ServiceProviderL(), TEBase::TCancel().CRef());

        	if (iStatusBundle)

        	    {

    			iStatusBundle->Close();

    			iStatusBundle = NULL;

        	    }

			// we'll complete when we get the response.

			iStatusMessage = aMessage;

			}

			break;

		case ECMAccessPointNotification_SetupThenAwaitThenGetResultOrSize:

			{

			const Messages::TNodeId& sp = ServiceProviderL();

			// ensure not already active. Should be guarded by client side code

			if (iNotificationActive)

			    {

			    CompleteMessage(aMessage, KErrInUse);

			    return;

			    }

			// unpack bundle

			TInt length = aMessage.GetDesLengthL(0);

			RBuf8 buffer;

			buffer.CreateL(length);

			CleanupClosePushL(buffer);

			aMessage.ReadL(0, buffer);

			CConnectionServParameterBundle* queryBundle = CConnectionServParameterBundle::LoadL(buffer);

			CleanupStack::PopAndDestroy(&buffer);

			CleanupStack::PushL(queryBundle);

			CRefCountOwnedParameterBundle* bundleOwner = new (ELeave)CRefCountOwnedParameterBundle(queryBundle);

			CleanupStack::Pop();

			bundleOwner->Open();

			CleanupClosePushL(*bundleOwner);

			// create and send message

			TNodeCtxId us(ETierNotificationActivity, NodeId()); //Pretend to be a MM node

			RClientInterface::OpenPostMessageClose(us, sp,

				TCFTierStatusProvider::TTierNotificationRegistration(bundleOwner, &aMessage).CRef());

			CleanupStack::Pop();

			// remember client request

			iNotificationActive = ETrue;

			iNotificationMessage = aMessage;

			}

			break;

		case ECMAccessPointNotification_AwaitThenGetResultOrSize:

			{

			// ensure already active but no outstanding request. Should be guarded by client side code

			if (!iNotificationActive)

			    {

			    CompleteMessage(aMessage, KErrNotReady);

			    return;

			    }

            if (!iNotificationMessage.IsNull())

			    {

			    CompleteMessage(aMessage, KErrInUse);

			    return;

			    }

			// pick from queue if anything in it..

			if(iNotificationQueue.Count())

				{

				CRefCountOwnedParameterBundle* bundleOwner = iNotificationQueue[0];

				const CConnectionServParameterBundle* queuedNotification = static_cast<const CConnectionServParameterBundle*>(bundleOwner->PtrL());

				TInt length = queuedNotification->Length();

				if (length > safeMessage.GetDesMaxLengthL(1))

					{

					// we're gonna need a bigger boat

					CompleteMessage(aMessage, length);

					}

				else

					{

					iNotificationQueue.Remove(0);

					CleanupClosePushL(*bundleOwner);

					RBuf8 buffer;

					buffer.CreateL(length);

					CleanupClosePushL(buffer);

					User::LeaveIfError(queuedNotification->Store(buffer));

					aMessage.WriteL(1, buffer);

					CompleteMessage(aMessage,KErrNone);

					CleanupStack::PopAndDestroy(&buffer);

					CleanupStack::PopAndDestroy(bundleOwner); // close ref on bundle

					}

				}

			else // we have to wait for a notification coming back from the tier so park the request

				{

				iNotificationMessage = aMessage;

				}

			}

			break;

		case ECMAccessPointNotification_GetResult:

			{

			if (!iNotificationActive || iNotificationQueue.Count() == 0)

			    {

			    CompleteMessage(aMessage, KErrNotReady);

			    return;

			    }

			CRefCountOwnedParameterBundle* bundleOwner = iNotificationQueue[0];

			const CConnectionServParameterBundle* queuedNotification = static_cast<const CConnectionServParameterBundle*>(bundleOwner->PtrL());

			iNotificationQueue.Remove(0);

			CleanupClosePushL(*bundleOwner);

			TInt length = queuedNotification->Length();

			// we should only be calling this after a realloc on the client side.

			//  so there should be no way the bundle won't fit

			if (length > safeMessage.GetDesMaxLengthL(1))

			    {

			    CompleteMessage(aMessage, KErrOverflow);

			    CleanupStack::PopAndDestroy(&bundleOwner);

			    return;

			    }

			RBuf8 buffer;

			buffer.CreateL(length);

			CleanupClosePushL(buffer);

			User::LeaveIfError(queuedNotification->Store(buffer));

			aMessage.WriteL(1, buffer);

			CompleteMessage(aMessage, KErrNone);

			CleanupStack::PopAndDestroy(&buffer);

			CleanupStack::PopAndDestroy(bundleOwner); // close ref on bundle

			}

			break;

		case ECMAccessPointNotification_Cancel:

			{

			// complete the original IPC

			if (!iNotificationActive)

			    {

			    // nothing to cancel

			    CompleteMessage(aMessage, KErrNone);

			    return;

			    }

			if (!iNotificationMessage.IsNull())

			    {

			    //TODO RZ we should really panic the client here.

			    //raising a defect to do this.

			    CompleteMessage(iNotificationMessage, KErrCancel);

			    }

			// create and send message

			TNodeCtxId us(ETierNotificationActivity, NodeId()); //Pretend to be a MM node

			__ASSERT_DEBUG(ServiceProvider()!=Messages::TNodeId::NullId(),User::Panic(KConnectionSessionPanic,EExpectedServiceProvider));

			RClientInterface::OpenPostMessageClose(us, ServiceProviderL(), TEBase::TCancel().CRef());

			// splat the queue

			iNotificationQueue.ResetAndDestroy();

			// we'll complete when we get the response.

			iNotificationMessage = aMessage;

			}

			break;

        case ECMApiExtBindIface:

        	CommsApiExtBindIfaceL(aMessage);

        	break;

		case ECMApiExtIfaceSend:

        case ECMApiExtIfaceSendReceive:

			CommsApiExtIfaceSendReceiveL(aMessage);

			break;

		case ECMApiExtIfaceClose:

			CloseExtensionInterface(aMessage);

			break;

		default:

			CompleteMessage(aMessage,KErrNotSupported);

		}

	}

void CConnectionSession::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)

/**

Entry point to CConnectionSession node

*/

	{

    // void to remove build warning

    (void)aSender;

	if ( aMessage.IsMessage<TEBase::TError>() )

		{

		TUint16 activityId = address_cast<TNodeCtxId>(&aRecipient)? address_cast<TNodeCtxId>(aRecipient).NodeCtx() : KActivityNull;

        ProcessError(activityId, aMessage);

		}

	else if ( aMessage.IsMessage<TCFTierStatusProvider::TTierStatus>() )

	    {

		HandleTierStatus(aMessage);

		}

	else if ( aMessage.IsMessage<TCFTierStatusProvider::TTierNotification>() )

		{

		HandleTierNotification(aMessage);

		}

	else if ( aMessage.IsMessage<TCFFactory::TPeerFoundOrCreated>() )

		{

		TCFFactory::TPeerFoundOrCreated& msg = message_cast<TCFFactory::TPeerFoundOrCreated>(aMessage);

		AttachToTierManager(msg.iNodeId);

		}

	else if ( aMessage.IsMessage<TCFServiceProvider::TJoinComplete>() )

		{

		__ASSERT_DEBUG(aSender == iTierManager, User::Panic(KSpecAssert_ESockSSockscnctn, 8));

		CompleteMessage(iAttachMessage, KErrNone);

		}

	else

		{

		LOG(ESockLog::Printf(KESockSessDetailTag, _L8("CConnectionSession(%08x):\tReceivedL - Unexpected message"), this));

		__ASSERT_DEBUG(0, User::Panic(KSpecAssert_ESockSSockscnctn, 9));

		}

	aMessage.ClearMessageId();

	}

void CConnectionSession::HandleTierStatus(const Messages::TSignatureBase& aCFMessage)

    {

	const TCFTierStatusProvider::TTierStatus& msg = message_cast<const TCFTierStatusProvider::TTierStatus>(aCFMessage);

	CRefCountOwnedParameterBundle* bundle = msg.iBundle;

	if( bundle == NULL || bundle->Ptr() == NULL)

		{

		__CFLOG_VAR((KTierTag,KConnServSubTag,_L8("Null bundle received. Discarding it.")));

		if(bundle)

			{

			bundle->Close();

			}

		return;

		}

    const CConnectionServParameterBundle& statusBundle = *static_cast<const CConnectionServParameterBundle*>(bundle->Ptr());

	if (iStatusMessage.IsNull())

		{

		_LOG_BUNDLE("Received status bundle when no outstanding request.", &statusBundle);

		// shouldn't have received this.

		__ASSERT_DEBUG(0, User::Panic(KSpecAssert_ESockSSockscnctn, 10));

		// swallow it in release mode

		bundle->Close();

		return;

		}

	TInt function = iStatusMessage.Function();

	switch (function)

		{

		case ECMAccessPointStatusQuery_DoThenGetResultOrSize:

			{

			__ASSERT_DEBUG(iStatusBundle == NULL, User::Panic(KSpecAssert_ESockSSockscnctn, 11));

			TInt length = statusBundle.Length();

            const Den::RSafeMessage& safeStatusMessage(static_cast<const Den::RSafeMessage&>(iStatusMessage));

			if (length > safeStatusMessage.GetDesMaxLengthL(1))

				{

				// we're gonna need a bigger boat

				iStatusBundle = msg.iBundle;

				CompleteMessage(iStatusMessage, length);

				}

			else

				{

				RBuf8 buffer;

				TInt err = buffer.Create(length);

				if (err == KErrNone)

				    {

    				err = statusBundle.Store(buffer);

    				if (err == KErrNone)

    				    {