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

 @internalComponent

*/

#include "ss_connlegacy.h"

#include <ss_std.h>

#include "ss_connstates.h"

#include <comms-infras/sockmes.h>

#include <cdblen.h>

#include <ss_glob.h>

#include <comms-infras/ss_log.h>

#include "SS_rslv.H"

#include <ss_sock.h>

#include <comms-infras/ss_sapshim.h>

#include <comms-infras/ss_connsettings.h>

#include "ss_subconn.h"

#include <comms-infras/esockmessages.h>

#include <comms-infras/ss_datamonitoringprovider.h>

#include <comms-infras/nifif.h>

#include "SS_conn.H"

#include <comms-infras/ss_datamon_apiext.h>

#include <comms-infras/ss_roles.h>

#include <commdbconnpref.h> //TCommDbConnPref

#include <comms-infras/ss_nodemessages_serviceprovider.h>

#include <elements/nm_messages_child.h>

#include "ss_internal_activities.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_ESockSSockscnLgc, "ESockSSockscnLgc");

#endif

using namespace ESock;

using namespace Messages;

using namespace MeshMachine;

using namespace Factories;

using namespace Den;

//************************************* old stuff ********************************//

//const TInt KNumberOfEmulatedSubConnections = 2;

const Factories::TAnyFn AConnectionLegacy::iInterfaceVTableF[] =

	{

	(Factories::TAnyFn)1,

	(Factories::TAnyFn)(TFactoryNotify<AConnectionLegacy>::Notification)

	};

AConnectionLegacy::~AConnectionLegacy()

    {

   	TSubConnectionEvent* subConnectionEvent;

	while (iSubConnectionEventQueue.Deque(subConnectionEvent))

		{

		LOG(ESockLog::Printf(KESockConnectionTag, _L("CConnection %08x:\tDequeuing and deleting subconnection event(%08x)"), this, subConnectionEvent));

		delete subConnectionEvent;

		subConnectionEvent = NULL;

		}

	iConnectionSocketBuf.Close();

	iConnectionClientBuf.Close();

	iConnectionInfoPtrArray.ResetAndDestroy();

	FinalCompleteAllBlockedMessages(KErrCancel);

	for (TInt i = 0; i < iSubConnections.Count(); ++i)

		{

		iSubConnections.Close();

		}

	}

void AConnectionLegacy::CancelProviderRequests()

	{

//	CancelServiceChangeNotification();

	}

void AConnectionLegacy::FinalCompleteAllBlockedMessages(TInt /* aReason */)

	{

	// If the all interface notification worker is running then post a

	// destroy to it.

	if(!iAllInterfaceNotificationWorker.IsNull())

		{

		TNodeCtxId dest(ECFActivityConnectionAllInterfaceNotification, iAllInterfaceNotificationWorker);

		RNodeInterface::OpenPostMessageClose(iConnection.Id(), dest, TEBase::TCancel().CRef());

		iAllInterfaceNotificationWorker.SetNull();

		}

	}

namespace ESock

{

class XConnectionFactoryAPQuery : public Factories::MFactoryQuery

	{

public:

	XConnectionFactoryAPQuery(TInt aAp)

	:iAp( aAp ) {}

protected:

	TInt iAp;

public:

	virtual TMatchResult Match(TFactoryObjectInfo& aConnectionInfo);

	};

}

MFactoryQuery::TMatchResult XConnectionFactoryAPQuery::Match(TFactoryObjectInfo& aConnectionInfo)

	{

	CConnectionProviderBase* connProv = static_cast<CConnectionProviderBase*>(aConnectionInfo.iInfo.iFactoryObject);

	return connProv->ProviderInfo().APId() == iAp ? MFactoryQuery::EMatch : MFactoryQuery::EContinue;

	}

static const TUid K_CIPProtoConnectionProviderFactory_iUid = {0x10281DD3};

void AConnectionLegacy::CompleteAttachL(ESock::TSelectionPrefs& aPrefs)

	{

	//We have built the new top (legacy) Cpr and now we need to make sure that

	//it is properly joined to the layer directly below it (i.e. IpProto).

	TConnPref& cp = aPrefs.Prefs();

	__ASSERT_DEBUG(cp.ExtensionId()==TConnPref::EConnPrefCommDb, User::Panic(KSpecAssert_ESockSSockscnLgc, 1)); //Must be legacy now

	__ASSERT_DEBUG(iConnection.ServiceProvider(), User::Panic(KSpecAssert_ESockSSockscnLgc, 2)); //The CConnection has been already joined

	RNodeInterface* sp = iConnection.ServiceProvider();

	Messages::ANode& connProvNode = sp->RecipientId().Node();

    MeshMachine::AMMNodeBase* cpr = reinterpret_cast<MeshMachine::AMMNodeBase*>(connProvNode.FetchNodeInterfaceL(AMMNodeBase::KInterfaceId));

    __ASSERT_DEBUG(cpr->GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EServProvider))==NULL, User::Panic(KSpecAssert_ESockSSockscnLgc, 3)); //This is why we are "legacy"

	CConnectionFactoryContainer& container = *static_cast<CPlayer&>(iConnection.Player()).SockManGlobals()->iConnectionFactories;

	CCommsFactoryBase* factory = static_cast<CCommsFactoryBase*>(container.FindFactory(K_CIPProtoConnectionProviderFactory_iUid));

    User::LeaveIfError(factory? KErrNone : KErrArgument);

    XConnectionFactoryAPQuery query(static_cast<const TCommDbConnPref&>(cp).IapId());

    CConnectionProviderBase* ipProtoCpr = static_cast<CConnectionProviderBase*>(factory->Find(query));

    User::LeaveIfError(ipProtoCpr? KErrNone : KErrArgument);

	cpr->AddClientL(ipProtoCpr->Id(),TClientType(TCFClientType::EServProvider, TCFClientType::EActive));

	TUint clientFlags = 0;

	if (aPrefs.Flags()&TSelectionPrefs::EMonitor)

		{

		__ASSERT_DEBUG(iConnection.IsMonitor(), User::Panic(KSpecAssert_ESockSSockscnLgc, 4)); //Well, we are attaching as a monitor, must be consistent!

		clientFlags = TCFClientType::EMonitor;

		}

	TRAPD(error,ipProtoCpr->AddClientL(cpr->Id(),TClientType(TCFClientType::ECtrl,clientFlags)));

	if (error!=KErrNone)

		{

		iConnection.ServiceProvider()->PostMessage(ipProtoCpr->Id(), TEChild::TLeft().CRef());

		User::Leave(error);

		}

	iConnection.ServiceProvider()->SetFlags(TCFClientType::EStarted);

	}

/**

Process RConnection messages

@exception Leaves on any error processing the request

*/

TInt AConnectionLegacy::ProcessMessageL(const RMessage2& aMessage)

	{

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

	switch (aMessage.Function())

		{

		case ECNAllSubConnectionNotification:

			AllSubConnectionNotificationL();

			break;

		case ECNCancelAllSubConnectionNotification:

			CancelAllSubConnectionNotification();

			break;

		case ECNEnumerateSubConnections:

			EnumerateSubConnectionsL(iConnection.SafeMessage());

			break;

		case ECNAllInterfaceNotification:

			AllInterfaceNotificationL(aMessage);

			break;

		case ECNCancelAllInterfaceNotification:

			CancelAllInterfaceNotification();

			break;

		case ECNGetConnectionInfo:

			GetConnectionInfoL(aMessage);

			break;

		case ECNServiceChangeNotification:

			RequestServiceChangeNotificationL(iConnection.SafeMessage());

			break;

		case ECNCancelServiceChangeNotification:

			CancelServiceChangeNotification(iConnection.SafeMessage());

			break;

		case ECNGetIntSetting:

			GetIntSettingL(iConnection.SafeMessage());

			break;

		case ECNGetBoolSetting:

			GetBoolSettingL(iConnection.SafeMessage());

			break;

		case ECNGetDes8Setting:

			GetDes8SettingL(iConnection.SafeMessage());

			break;

		case ECNGetDes16Setting:

			GetDes16SettingL(iConnection.SafeMessage());

			break;

		case ECNGetLongDesSetting:

			GetLongDesSettingL(iConnection.SafeMessage());

			break;

		case ESCPSProgressNotification:

			iConnection.SetReturn(KErrNotSupported);

			break;

		case ESCPSCancelProgressNotification:

			break;

		case ESCPSDataTransferred:

			DataTransferredL(iConnection.SafeMessage());

			break;

		case ESCPSDataTransferredCancel:

			break;

		case ESCPSDataSentNotificationRequest:

			DataSentNotificationRequestL(iConnection.SafeMessage());

			break;

		case ESCPSDataSentNotificationCancel:

			DataSentNotificationCancel(iConnection.SafeMessage());

			break;

		case ESCPSDataReceivedNotificationRequest:

			DataReceivedNotificationRequestL(iConnection.SafeMessage());

			break;

		case ESCPSDataReceivedNotificationCancel:

			DataReceivedNotificationCancel(iConnection.SafeMessage());

			break;

		case ESCPSIsSubConnectionActiveRequest:

			IsSubConnectionActiveRequestL(iConnection.SafeMessage());

			break;

		case ESCPSIsSubConnectionActiveCancel:

			IsSubConnectionActiveCancel(iConnection.SafeMessage());

			break;

		case ESCPSGetSubConnectionInfo:

			GetSubConnectionInfoL(iConnection.SafeMessage());

			break;

		default:

			iConnection.SetReturn(KErrNotSupported);

			LOG(ESockLog::Printf(KESockConnectionTag, _L8("CConnectionLegacy(%08x)::ProcessMessageL - unsupported IPC %d received"), this, aMessage.Function()));

		}

		return KErrNone;

	}

/**

Control method to send a general command towards the interface.

*/

void AConnectionLegacy::ControlL(TUint aOptionName, TUint aMessageId)

	{

	if (aMessageId == KCOLConnection)

		{

		switch(aOptionName)

			{

			case KCoEnumerateConnectionClients:

				EnumerateConnectionClientsL();

				return;

			case KCoGetConnectionClientInfo:

				GetConnectionClientInfoL();

				return;

			case KCoEnumerateConnectionSockets:

				EnumerateConnectionSocketsL();

				return;

			case KCoGetConnectionSocketInfo:

				GetConnectionSocketInfoL();

				return;

			default:

				User::Leave(KErrNotSupported);

			}

		}

	}

/**

Get the number of currently active subconnections

@see RConnection::EnumerateSubConnections for notes on the difference in behaviour between this function and EnumerateConnectionsL()

*/

void AConnectionLegacy::EnumerateSubConnectionsL(const Den::RSafeMessage& aMessage)

	{

	RNodeInterface* sp = iConnection.ServiceProvider();

    if(!sp || !(sp->Flags() & TCFClientType::EStarted))

		{

		LOG(ESockLog::Printf(KESockConnectionTag, _L8("CConnection (AConnectionLegacy) [this=%08x] EnumerateSubConnectionsL KErrNotReady(-18)"), &iConnection));

        iConnection.SetReturn(KErrNotReady);

        return;

		}

	iConnection.CMMSockSubSession::ReceivedL(aMessage.Function(), TLegacyEnumerateSubConnections(aMessage));

	iConnection.DontCompleteCurrentRequest();

	}

void AConnectionLegacy::AllInterfaceNotificationL(const RMessage2& aMessage)

	{

	if(!iAllInterfaceNotificationMessage.IsNull() || iConnection.ServiceProvider())

		{

		iConnection.SetReturn(KErrInUse);

		return;

		}

	iAllInterfaceNotificationMessage = aMessage;

	iConnection.DontCompleteCurrentRequest();

	if(iAllInterfaceNotificationWorker.IsNull())

		{

		CAllInterfaceNotificationWorker* worker = new(ELeave) CAllInterfaceNotificationWorker(iConnection);

		iAllInterfaceNotificationWorker = worker->Id();

		TNodeCtxId dest(ECFActivityConnectionAllInterfaceNotification, iAllInterfaceNotificationWorker);

		RNodeInterface::OpenPostMessageClose(iConnection.Id(), dest, TCFServiceProvider::TStart().CRef());

		}

	CompleteAllInterfaceNotificationL(KErrNone);

	}

void AConnectionLegacy::CompleteAllInterfaceNotificationL(TInt aError)

	{

	if (!iAllInterfaceNotificationMessage.IsNull())

		{

		if(aError == KErrNone)

			{

			if (!iNotificationQueue.IsEmpty())

				{

				TInterfaceNotification notification;

				iNotificationQueue.Deque(notification);

				TInterfaceNotificationBuf buf(notification);

				// Write the buffer to the client

				iAllInterfaceNotificationMessage.WriteL(0, buf);

			    LOG(ESockLog::Printf(KESockConnectionTag, _L8("AConnectionLegacy [this=%08x] CompleteAllInterfaceNotificationL, RMessage2::Complete (%08x) with 0"), &iConnection, iAllInterfaceNotificationMessage.Handle()));

				iAllInterfaceNotificationMessage.Complete(KErrNone);

				iAllInterfaceNotificationMessage = RMessage2();

				}

			}

		else

			{

            LOG(ESockLog::Printf(KESockConnectionTag, _L8("AConnectionLegacy [this=%08x] CompleteAllInterfaceNotificationL, RMessage2::Complete (%08x) with %d"), &iConnection, iAllInterfaceNotificationMessage.Handle(), aError));

			iAllInterfaceNotificationMessage.Complete(aError);

			iAllInterfaceNotificationMessage = RMessage2();

			}

		}

	}

void AConnectionLegacy::CancelAllInterfaceNotification()

	{

	if(!iAllInterfaceNotificationMessage.IsNull())

		{

		iAllInterfaceNotificationMessage.Complete(KErrCancel);

		}

	}

void AConnectionLegacy::RequestServiceChangeNotificationL(const Den::RSafeMessage& aMessage)

	{

	RNodeInterface* currServiceProvider = iConnection.ServiceProvider();

    if (!currServiceProvider)

        {

		LOG(ESockLog::Printf(KESockConnectionTag, _L8("AConnectionLegacy [this=%08x] RequestServiceChangeNotificationL KErrNotReady"), &iConnection));

        iConnection.SetReturn(KErrNotReady);

        return;

        }

	if(iServiceChangeNotificationPending)

		{

		iConnection.SetReturn(KErrInUse);

		return;

		}

    // This message needs to be directed towards the MCpr - Service change notification occurs

    // during reconnection. We violate the principle of left hand nodes not instructing right

    // hand nodes. Since this is for legacy support its ok for now. The CPr that implements

    // the Api is expected to forward this message to its MCpr

	iServiceChangeNotificationPending = ETrue;

	TCprRequestServiceNotification msg(iConnection.Id(), aMessage);

	iConnection.CMMSockSubSession::ReceivedL(aMessage.Function(), msg);

	iConnection.DontCompleteCurrentRequest();

	}

void AConnectionLegacy::CancelServiceChangeNotification(const Den::RSafeMessage& aMessage)

	{

    // This message needs to be directed towards the MCpr - Service change notification occurs

    // during reconnection. We violate the principle of left hand nodes not instructing right

    // hand nodes. Since this is for legacy support its ok for now. The CPr that implements

    // the Api is expected to forward this message to its MCpr

	LOG(ESockLog::Printf(KESockConnectionTag, _L8("AConnectionLegacy [this=%08x] CancelServiceChangeNotification KErrCancel"), &iConnection));	

	const RPointerArray<CNodeActivityBase>& activities = iConnection.Activities();

	for (TInt i = 0; i < activities.Count(); i++)

		{

		if (activities[i]->ActivitySigId() == ESock::ECFActivityConnectionLegacyRMessage2Handler)

			{

			ConnActivities::CConnLegacyRMessage2Activity* act = static_cast<ConnActivities::CConnLegacyRMessage2Activity*>(activities[i]);

			if (act->iSafeMessage.Function() == ECNServiceChangeNotification)

				{

				act->SetCancelRequest(aMessage);

				iConnection.CMMSockSubSession::ReceivedL(act->iSafeMessage.Function(), TEBase::TCancel().CRef());

				iConnection.DontCompleteCurrentRequest();

				}

			}

		}

	iServiceChangeNotificationPending = EFalse;

	}

/**

Return information about a single connection that was previously

enumerated using EnumerateConnectionsL

This is the server-side implementation of the RConnection

function TInt GetConnectionInfo(TUint aIndex, TDes8& aConnectionInfo).

*/

void AConnectionLegacy::GetConnectionInfoL(const RMessage2& aMessage)

	{

	TUint index = aMessage.Int0();

	// Make sure the client isn't using an invalid argument (*client* connection numbering starts from 1)

	if(index == 0)

		{

		iConnection.SetReturn(KErrArgument);

		return;

		}

	// Make sure the client isn't trying to access a connection that doesn't exist

	if(index > static_cast<TUint>(iConnectionInfoPtrArray.Count()))

		{

		iConnection.SetReturn(KErrNotFound);

		return;

		}

	index = index - 1;	// alter the client-provided index (indexed from one) to act as a index for the array (indexed from zero)

	// check the client argument's version to see which one it's using

	TConnArgBase clientArg;

	TPckg<TConnArgBase> argPckg(clientArg);

	aMessage.ReadL(1, argPckg);

	TUint8 clientVersion = clientArg.Version();

	// Translate between versions of TConnectionInfo depending on what client passes in

	__ASSERT_DEBUG(iConnectionInfoPtrArray[index]->Version() == KConnArgVersion2, User::Panic(KSpecAssert_ESockSSockscnLgc, 5));	// check that the connection provider has put TConnectionInfoV2's in the queue

	if(clientVersion == KConnArgVersion1)

		{

		TConnectionInfo connectionInfoV1;

		connectionInfoV1.iIapId = iConnectionInfoPtrArray[index]->iIapId;

		connectionInfoV1.iNetId = iConnectionInfoPtrArray[index]->iNetId;

		TPckg<TConnectionInfo> info(connectionInfoV1);

		LOG( ESockLog::Printf(KESockConnectionTag, _L("AConnectionLegacy: Client called GetConnectionInfo (client ver=%d, esock ver=%d), writing [%S](%d bytes) to client side"), clientArg.Version(), iConnectionInfoPtrArray[index]->Version(), &info, info.Size()); )

		aMessage.WriteL(1, info);

		}

	else

		{

		if(clientVersion == KConnArgVersion2)

			{

			// downcast from TConnectionInfo pointer to TConnectionInfoV2 pointer; we can do this safely because the earlier ASSERT() checked that these were TConnectionInfoV2s

			TPckg<TConnectionInfoV2> info(*(static_cast<TConnectionInfoV2*>(iConnectionInfoPtrArray[index])));

			LOG( ESockLog::Printf(KESockConnectionTag, _L("AConnectionLegacy: Client called GetConnectionInfo (client ver=%d, esock ver=%d), writing [%S](%d bytes) to client side"), clientArg.Version(), iConnectionInfoPtrArray[index]->Version(), &info, info.Size()); )

			aMessage.WriteL(1, info);

			}

		else

			{

			LOG( ESockLog::Printf(KESockConnectionTag, _L("AConnectionLegacy: Invalid version of argument to GetConnectionInfo (client ver=%d, esock ver=%d)"), clientArg.Version(), iConnectionInfoPtrArray[index]->Version()); )

			iConnection.SetReturn(KErrArgument);

			}

		}

	}

/**

Extract a single enumeration information element from a buffer of elements

@param aBuffer the buffer from which to extract the information element

@param aCount the total number of elements in the buffer

@param aSize the size of each information element

@param aIndex the position of the element to retrieve in the buffer. Index is 1-based.

@param aPckg the TPckg<> in which to return the information element

@exception leaves with KErrOverflow if the index given is past the end of the buffer

*/

void AConnectionLegacy::ExtractEnumInfoL(RBuf8& aBuffer, TUint aCount, TInt aSize, TUint aIndex, TDes8& aPckg)

	{

	if (aBuffer.Length() == 0)

		{

		LOG( ESockLog::Printf(KESockConnectionTag, _L8("AConnectionLegacy %08x ExtractEnumInfoL KErrNotReady"), this) );

		User::Leave(KErrNotReady);

		}