// 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_nodemessages_legacy.h"

#include <comms-infras/api_ext_list.h>

#include <comms-infras/api_ext_msg.h>

#include <cdblen.h>

#include <commdb.h>

#include <ss_glob.h>

#include <comms-infras/ss_connprov.h>

#include "ss_connstates.h"

#include <comms-infras/ss_connlegacy.h>

#include <comms-infras/ss_thread.h>

#include <comms-infras/metatype.h>

#include <comms-infras/ss_datamon_apiext.h>

#include <comms-infras/ss_connlegacy.h>

#include "SS_conn.H"

#include <comms-infras/ss_nodemessages_internal_esock.h>

#include "ss_internal_activities.h" 

// although we don't need the XConnectionQueryBase::LoadL() method

// including this header forces us to link against commsdataobjects.lib

// when compiling with Armv5

#include <comms-infras/connectionqueryset.h>

#include <comms-infras/ss_log.h>

#include <comms-infras/ss_commsdataobject.h>

#include <comms-infras/ss_roles.h>

#include <ss_sock.h>

#include "SS_rslv.H"

#include <comms-infras/ss_subconnflow.h>

#include <elements/responsemsg.h>

#ifdef __CFLOG_ACTIVE

	#define KShimCprTag KESockConnectionTag

	_LIT8(KShimCprSubTag, "shimcpr");	// logging tag

#endif

using namespace ESock;

using namespace Elements;

using namespace Messages;

using namespace MeshMachine;

/**

 * TCFSigLegacyRMessage2Ext

 */

TCFSigLegacyRMessage2Ext::TCFSigLegacyRMessage2Ext()

    : Messages::TSignatureBase() {}

TCFSigLegacyRMessage2Ext::TCFSigLegacyRMessage2Ext(const Messages::TNodeSignal::TMessageId& aMessageId, const Den::RSafeMessage& aMessage)

	: Messages::TSignatureBase(aMessageId), iMessage() { iMessage.Duplicate(aMessage); }

TBool TCFSigLegacyRMessage2Ext::HasInterface(MeshMachine::TNodeContextBase& aContext, TInt aInterface)

	{

	TRAPD(err, FetchInterfaceL(aContext.Node(), aInterface));

    if (err != KErrNone)

		{

		return EFalse;

		}

	else

		{

		return ETrue;

		}

	}

TAny* TCFSigLegacyRMessage2Ext::FetchInterfaceL(MeshMachine::AMMNodeBase& aNode, TInt aInterface)

	{

	NetInterfaces::TInterfaceControl* ic = NULL;

	ic = aNode.Id().Node().FetchNodeInterfaceControlL(aInterface);

	return ic->FetchInterfaceL(aInterface);

	}

TAny* TCFSigLegacyRMessage2Ext::FetchInterfaceL(Messages::ANode& aNode, TInt aInterface)

	{

	NetInterfaces::TInterfaceControl* ic = NULL;

	ic = aNode.FetchNodeInterfaceControlL(aInterface);

	return ic->FetchInterfaceL(aInterface);

	}

void TCFSigLegacyRMessage2Ext::ForwardRequestL(MeshMachine::TNodeContextBase& aContext)

	{

	ASSERT(aContext.Activity() != NULL);

	RNodeInterface* rcpt = NULL;

	/* At the connection level we want to go down active serviceprovider, as there are multiple

	   and the first one is usually an scpr */

	if (aContext.Activity()->ActivitySigId() == ECFActivityConnectionLegacyRMessage2Handler)

		{

		rcpt = aContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EServProvider, TCFClientType::EActive),

			Messages::TClientType(0, Messages::TClientType::ELeaving));

		}

	else

		{

		rcpt = aContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EServProvider),

			Messages::TClientType(0, Messages::TClientType::ELeaving));

		}

    if(rcpt)

    	{

		aContext.Activity()->PostRequestTo(*rcpt, *this);

    	}

	else

		{

		User::Leave(KErrNotFound);

		}

	}

EXPORT_C TInt TCFSigLegacyRMessage2PlatsecExt::SecureId(TSecureId& aResult) const

    {

    aResult = iMessage.SecureId();

    return KErrNone;

    }

EXPORT_C TInt TCFSigLegacyRMessage2PlatsecExt::VendorId(TVendorId& aResult) const

    {

    aResult = iMessage.VendorId();

    return KErrNone;

    }

EXPORT_C TBool TCFSigLegacyRMessage2PlatsecExt::HasCapability(const TCapability aCapability) const

    {

    return iMessage.HasCapability(aCapability);

    }

EXPORT_C TInt TCFSigLegacyRMessage2PlatsecExt::CheckPolicy(const TSecurityPolicy& aPolicy) const

    {

    TBool platsecResult;

    platsecResult = aPolicy.CheckPolicy(iMessage);

    if (!platsecResult)

        {

        return KErrPermissionDenied;

        }

    return KErrNone;

    }

/**

 *

 * TMCprGetConnectionSetting

 *

 */

TBool TMCprGetConnectionSetting::CanProcess(MeshMachine::TNodeContextBase& aContext)

	{

	return HasInterface(aContext, MLinkMCprLegacyDataAccessApiExt::KInterfaceId);

	}

void TMCprGetConnectionSetting::ForwardL(MeshMachine::TNodeContextBase& aContext)

	{

	if (aContext.Activity()->ActivitySigId() == ECFActivityConnectionLegacyRMessage2Handler)

		{

		TClientIter<TDefaultClientMatchPolicy> iter = aContext.Node().GetClientIter<TDefaultClientMatchPolicy>(TClientType(TCFClientType::EServProvider, TCFClientType::EAvailabilityProvider));

		RNodeInterface* sp = iter[0];

		if (!sp)

			{

			User::Leave(KErrNotReady);

			}

		aContext.Activity()->PostRequestTo(*sp, *this);		

		}

	else

		{

		ForwardRequestL(aContext);

		}

	}

void TMCprGetConnectionSetting::ProcessL(MeshMachine::TNodeContextBase& aContext)

	{

	TAny* interface = FetchInterfaceL(aContext.Node(), MLinkMCprLegacyDataAccessApiExt::KInterfaceId);

	ASSERT(interface);

	MLinkMCprLegacyDataAccessApiExt& dataAccessItf = *static_cast<MLinkMCprLegacyDataAccessApiExt*>(interface);

	TBuf<KCommsDbSvrMaxColumnNameLength*2 +1> field;

	iMessage.ReadL(0, field);

	switch (iSettingType)

		{

	case EIntSetting:

		{

		TUint32 value(0);

		dataAccessItf.GetIntSettingL(field, value, this);

		TPckg<TUint32> pckg(value);

		iMessage.WriteL(1, pckg);

		}

		break;

	case EBoolSetting:

	    {

		TBool value(EFalse);

		dataAccessItf.GetBoolSettingL(field, value, this);

		TPckg<TBool> pckg(value);

		iMessage.WriteL(1, pckg);

		}

		break;

    case EDes8Setting:

	    {

		TBuf8<KCommsDbSvrMaxFieldLength> value;

		dataAccessItf.GetDes8SettingL(field, value, this);

		iMessage.WriteL(1, value);

		}

		break;

    case EDes16Setting:

	    {

		TBuf16<KCommsDbSvrRealMaxFieldLength> value;

		dataAccessItf.GetDes16SettingL(field, value, this);

		iMessage.WriteL(1, value);

		}

		break;

	case ELongDesSetting:

	    {

		HBufC* valueBuf(NULL);

		dataAccessItf.GetLongDesSettingL(field, valueBuf, this);

		CleanupStack::PushL(valueBuf);

		TPtr valuePtr(valueBuf->Des());

		iMessage.WriteL(1,valuePtr);

		CleanupStack::PopAndDestroy(valueBuf);

		}

		break;

    default:

		// Should never be able to reach here

		__ASSERT_ALWAYS(EFalse, User::Panic(_L("LegacyDataAccess"), KErrArgument));

		break;

		}

	__CFLOG_VAR((KShimCprTag, KShimCprSubTag, _L8("TCprGetConnectionSetting %08x:\tDispatchL() completing message (%08X) with KErrNone"),

			this, iMessage.Handle()));

	RLegacyResponseMsg responseMsg(aContext, iMessage, iMessage.Int0());

	responseMsg.Complete(KErrNone);

	}

/**

 *

 * TCprRetrieveProgress

 *

 */

TBool TCprRetrieveProgress::CanProcess(MeshMachine::TNodeContextBase& aContext)

	{

	return HasInterface(aContext, MLinkCprApiExt::KInterfaceId);

	}

void TCprRetrieveProgress::ForwardL(MeshMachine::TNodeContextBase& aContext)

	{

	ForwardRequestL(aContext);

	}

void TCprRetrieveProgress::ProcessL(MeshMachine::TNodeContextBase& aContext)

	{

	TAny* interface = NULL;

	TRAPD(err, interface = FetchInterfaceL(aContext.Node(), MLinkCprApiExt::KInterfaceId));

	ASSERT(interface);

	MLinkCprApiExt::TProgressBuf prog;

	RLegacyResponseMsg responseMsg(aContext, iMessage, iMessage.Int0());

	if (err == KErrNotFound)

	    {

        // If an interface can't be found complete the client with the last

        // progress cached on the CConnection

        MLinkCprApiExt::TProgressBuf prog(iLastProgress);

        responseMsg.WriteL(0, prog);

		__CFLOG_VAR((KShimCprTag, KShimCprSubTag, _L8("TCprRetrieveProgress %08x:\tDispatchL() completing message (%08X) with KErrNone"),

							 this, iMessage.Handle()));

        responseMsg.Complete(KErrNone);

        return;

	    }

    if (interface)

    	{

    	MLinkCprApiExt& linkCprItf = *static_cast<MLinkCprApiExt*>(interface);

    	linkCprItf.ProgressL(prog);

        responseMsg.WriteL(0, prog);

		__CFLOG_VAR((KShimCprTag, KShimCprSubTag, _L8("TCprRetrieveProgress %08x:\tDispatchL() completing message (%08X) with KErrNone"),

							 this, iMessage.Handle()));

        responseMsg.Complete(KErrNone);

    	}

	}

TInt TCprRetrieveProgress::CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError)

	{

	CConnection* conn = static_cast<CConnection*>(&aContext.Node());

    ConnActivities::CConnLegacyRMessage2Activity* act = static_cast<ConnActivities::CConnLegacyRMessage2Activity*>(aContext.Activity());

    if (aError == KErrNotFound)

        {

        TPckgBuf<TStateChange> progressBuf;

		progressBuf().iStage = conn->iLastProgress.iStage;

		progressBuf().iError = conn->iLastProgress.iError;

        TRAPD(err, act->iSafeMessage.WriteL(0, progressBuf));

		return err;

        }

	return aError;

	}

/**

 *

 * TCprRetrieveLastProgressError

 *

 */

TBool TCprRetrieveLastProgressError::CanProcess(MeshMachine::TNodeContextBase& aContext)

	{

	return HasInterface(aContext, MLinkCprApiExt::KInterfaceId);

	}

void TCprRetrieveLastProgressError::ForwardL(MeshMachine::TNodeContextBase& aContext)

	{

	ForwardRequestL(aContext);

	}

void TCprRetrieveLastProgressError::ProcessL(MeshMachine::TNodeContextBase& aContext)

	{

	TAny* interface = NULL;

	TRAPD(err, interface = FetchInterfaceL(aContext.Node(), MLinkCprApiExt::KInterfaceId));

	ASSERT(interface);

	MLinkCprApiExt::TProgressBuf prog;

	RLegacyResponseMsg responseMsg(aContext, iMessage, iMessage.Int0());

	if (err == KErrNotFound)

        {

        // If an interface can't be found complete the client with the last

        // progress error cached on the CConnection

        MLinkCprApiExt::TProgressBuf prog(iLastProgressError);

        responseMsg.WriteL(0, prog);

		__CFLOG_VAR((KShimCprTag, KShimCprSubTag, _L8("TCprRetrieveLastProgressError %08x:\tDispatchL() completing message (%08X) with KErrNone"),

							 this, iMessage.Handle()));

		responseMsg.Complete(KErrNone);

        return;

        }

    if (interface)

    	{

    	MLinkCprApiExt& linkCprItf = *static_cast<MLinkCprApiExt*>(interface);

    	linkCprItf.LastProgressError(prog);

    	responseMsg.WriteL(0, prog);

		__CFLOG_VAR((KShimCprTag, KShimCprSubTag, _L8("TCprRetrieveLastProgressError %08x:\tDispatchL() completing message (%08X) with KErrNone"),

							 this, iMessage.Handle()));

        responseMsg.Complete(KErrNone);

    	}

	}

TInt TCprRetrieveLastProgressError::CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError)

	{

	CConnection* conn = static_cast<CConnection*>(&aContext.Node());

    ConnActivities::CConnLegacyRMessage2Activity* act = static_cast<ConnActivities::CConnLegacyRMessage2Activity*>(aContext.Activity());

    if (aError == KErrNotFound)

        {

        TPckgBuf<TStateChange> progressBuf;

		progressBuf().iStage = conn->iLastProgressError.iStage;

		progressBuf().iError = conn->iLastProgressError.iError;

		conn->ResetLastProgressError();

        TRAPD(err, act->iSafeMessage.WriteL(0, progressBuf));

		return err;

        }

	return aError;

	}

/**

 *

 * TCprRequestServiceNotification

 *

 */

TBool TCprRequestServiceNotification::CanProcess(MeshMachine::TNodeContextBase& aContext)

	{

	return HasInterface(aContext, MLinkCprServiceChangeNotificationApiExt::KInterfaceId);

	}

void TCprRequestServiceNotification::ForwardL(MeshMachine::TNodeContextBase& aContext)

	{

	ForwardRequestL(aContext);

	}

void TCprRequestServiceNotification::ProcessL(MeshMachine::TNodeContextBase& aContext)

	{

	TAny* interface = FetchInterfaceL(aContext.Node(), MLinkCprServiceChangeNotificationApiExt::KInterfaceId);

	ASSERT(interface);

	MLinkCprServiceChangeNotificationApiExt& linkCprItf = *static_cast<MLinkCprServiceChangeNotificationApiExt*>(interface);

	RLegacyResponseMsg response(aContext, iMessage, iMessage.Int0());

	linkCprItf.RequestServiceChangeNotificationL(iSender, response);

	}

void TCprRequestServiceNotification::Cancel(MeshMachine::TNodeContextBase& aContext)

	{

	TAny* interface = FetchInterfaceL(aContext.Node(), MLinkCprServiceChangeNotificationApiExt::KInterfaceId);

	ASSERT(interface);

	MLinkCprServiceChangeNotificationApiExt& linkCprItf = *static_cast<MLinkCprServiceChangeNotificationApiExt*>(interface);

	linkCprItf.CancelServiceChangeNotification(iSender);

	}

/**

 *

 * TCprSendIoctl

 *

 */

TBool TCprSendIoctl::CanProcess(MeshMachine::TNodeContextBase& /*aContext*/)

	{

	return EFalse; // always forward. If a node is going to process, it will do regardless of this

	}

void TCprSendIoctl::ForwardL(MeshMachine::TNodeContextBase& aContext)

	{

	ForwardRequestL(aContext);

	}

void TCprSendIoctl::ProcessL(MeshMachine::TNodeContextBase& /*aContext*/)

	{

	// do nothing, the nodes that receive the ioctl will handle it themselves

	ASSERT(0);

	}

void TCprSendIoctl::Cancel(MeshMachine::TNodeContextBase& /*aContext*/)

	{

	// cancellation is handled by the node handling the ioctl, this should never be called

	ASSERT(0);

	}

/**

 *

 * TCprFactEnumerateConnections

 *

 */

TBool TCprFactEnumerateConnections::CanProcess(MeshMachine::TNodeContextBase& /*aContext*/)

	{

	return ETrue;

	}

void TCprFactEnumerateConnections::ForwardL(MeshMachine::TNodeContextBase& /*aContext*/)

	{

	ASSERT(0); // should never forward

	}

void TCprFactEnumerateConnections::ProcessL(MeshMachine::TNodeContextBase& aContext)

	{

	RLegacyResponseMsg responseMsg(aContext, iMessage, iMessage.Int0());

    const TNodeId& nodeId = address_cast<const TNodeId>(aContext.NodeId());  //This message type operates on nodes

    ASSERT(nodeId == SockManGlobals::Get()->GetPlaneFC(TCFPlayerRole(TCFPlayerRole::EConnPlane)));

    TAny* interface = NULL;

    TInt count = 0;

    TRAP_IGNORE(interface = FetchInterfaceL(nodeId.Node(), MLinkCprFactApiExt::KInterfaceId));

    if (interface)

        {

    	MLinkCprFactApiExt* cenumapi = reinterpret_cast<MLinkCprFactApiExt*>(interface);

    	cenumapi->EnumerateConnectionsL(*iConnectionInfoPtrArray);

    	count = iConnectionInfoPtrArray->Count();

        }

	responseMsg.WriteL(0, TPckg<TUint>(count));

	__CFLOG_VAR((KShimCprTag, KShimCprSubTag, _L8("TCprFactEnumerateConnections %08x:\tDispatchL() completing message (%08X) with KErrNone"),

						 this, iMessage.Handle()));

	responseMsg.Complete(KErrNone);

    }

/**

 * TCprAllSubConnectionNotificationEnable

 * This is the only legacy self dispatcher left.

 */

void TCprAllSubConnectionNotificationEnable::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)

    {

    const TNodeId& nodeId = address_cast<const TNodeId>(aRecipient);  //This message type operates on nodes

	TAny* interface = FetchInterfaceOrForwardMsgL(aSender, *this, nodeId.Node(), MLinkCprApiExt::KInterfaceId);

    if (interface)

    	{

    	MLinkCprApiExt& linkCprItf = *static_cast<MLinkCprApiExt*>(interface);

    	linkCprItf.AllSubConnectionNotificationEnable();

    	}

    }

void TCprAllSubConnectionNotificationEnable::Error(const TRuntimeCtxId& /*aSender*/, const TRuntimeCtxId& /*aRecipient*/, TInt /*aError*/)

    {

    ASSERT(EFalse);//should never get there. if so than we need to derive from TCFSigRMessage2Ext

    //to add RMessage and complete with error

    }

void CLegacyDataMonitoringResponder::DoCancelRequest()

	{

	iLegacyResponseMsg.Complete(KErrCancel);

	}

void CLegacyDataMonitoringResponder::DoDataTransferred(TUint32 aReceivedBytes, TUint32 aSentBytes)

	{

	TPckg<TUint> uplinkDataVolumePckg(aSentBytes);

	TPckg<TUint> downlinkDataVolumePckg(aReceivedBytes);

	TInt err = iLegacyResponseMsg.Write(1, uplinkDataVolumePckg);

	if(err != KErrNone)

		{

		iLegacyResponseMsg.Complete(err);

		return;

		}

	err = iLegacyResponseMsg.Write(2, downlinkDataVolumePckg);