--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/ssock/ss_apiext_messages.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,239 @@
+// 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
+*/
+
+#include "ss_apiext_messages.h"
+#include <comms-infras/ss_api_ext.h>
+#include <comms-infras/ss_thread.h>
+#include <ss_glob.h>
+#include <comms-infras/es_api_ext.h>
+
+using namespace ESock;
+using namespace Elements;
+using namespace Messages;
+using namespace MeshMachine;
+
+// ----- TOpenExtensionInterface -----
+
+void TOpenExtensionInterface::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)
+    {
+    const TNodeId& nodeId = address_cast<TNodeId>(aRecipient);
+	TAny* itf = FetchInterfaceOrForwardMsgL(aSender, *this, nodeId.Node(), iInterfaceId);
+
+	if(itf)
+		{
+		AExtensionInterfaceThickBase& baseItf = *static_cast<AExtensionInterfaceThickBase*>(itf);
+
+		//This fn will not allow an interface to be reqistered twice
+		SockManGlobals::Get()->iCommsApiExtRegister.RegisterInterfaceL(iInterfaceId, baseItf.MsgImplTid(), iClientId);
+
+		//When completed with an error code (!=KErrNone), this responder will deregister interface for this client
+		baseItf.OpenExtensionInterface(iClientId, nodeId, CCommsApiExtIpcOpenResponder::NewL(iInterfaceId, iClientId, iMessage));
+		// coverity [memory_leak] - the ownership of CCommsApiExtIpcOpenResponder::NewL(iInterfaceId, iClientId, iMessage) 
+		// is taken by the function, OpenExtensionInterface. No need to setup cleanup stack for memory leak
+		}
+	}
+
+void TOpenExtensionInterface::Error(const TRuntimeCtxId& /*aSender*/, const TRuntimeCtxId& /*aRecipient*/, TInt aError)
+	{
+   	if (aError==KErrNotFound)
+   		{
+   		//This IPC call has not been served.
+   		aError=KErrNotSupported;
+   		}
+
+	iMessage.Complete(aError);
+	}
+
+DEFINE_MVIP_CTR(TOpenExtensionInterface)
+
+START_ATTRIBUTE_TABLE(TOpenExtensionInterface, KExtItfMsgImplementationUid, EOpenExtensionInterface)
+	REGISTER_ATTRIBUTE(TOpenExtensionInterface, iClientId, TMeta<TUint>)
+	REGISTER_ATTRIBUTE(TOpenExtensionInterface, iInterfaceId, TMeta<TSupportedCommsApiExt>)
+END_ATTRIBUTE_TABLE_BASE(TCFSigRMessage2Ext, ESignatureRMessage2)
+
+// ----- TCloseExtensionInterface -----
+
+void TCloseExtensionInterface::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)
+    {
+    const TNodeId& nodeId = address_cast<TNodeId>(aRecipient);
+	TAny* itf = FetchInterfaceOrForwardMsgL(aSender, *this, nodeId.Node(), iInterfaceId);
+
+	if(itf)
+		{
+		AExtensionInterfaceThickBase& baseItf = *static_cast<AExtensionInterfaceThickBase*>(itf);
+		baseItf.CloseExtensionInterface(iClientId);
+		SockManGlobals::Get()->iCommsApiExtRegister.DeRegisterInterface(iInterfaceId, iClientId);
+		iMessage.Complete(KErrNone);
+		}
+	}
+
+void TCloseExtensionInterface::Error(const TRuntimeCtxId& /*aSender*/, const TRuntimeCtxId& /*aRecipient*/, TInt /*aError*/)
+	{
+	// Anything to do?
+	}
+
+DEFINE_MVIP_CTR(TCloseExtensionInterface)
+
+START_ATTRIBUTE_TABLE(TCloseExtensionInterface, KExtItfMsgImplementationUid, ECloseExtensionInterface)
+	REGISTER_ATTRIBUTE(TCloseExtensionInterface, iClientId, TMeta<TUint>)
+	REGISTER_ATTRIBUTE(TCloseExtensionInterface, iInterfaceId, TMeta<TSupportedCommsApiExt>)
+END_ATTRIBUTE_TABLE_BASE(TCFSigRMessage2Ext, ESignatureRMessage2)
+
+// ----- TCancelAndCloseAllClientExtItf -----
+
+void TCancelAndCloseAllClientExtItf::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)
+	{
+	CancelCloseAllAndForwardMsgL(aSender, *this, address_cast<TNodeId>(aRecipient).Node());
+	}
+
+void TCancelAndCloseAllClientExtItf::Error(const TRuntimeCtxId& /*aSender*/, const TRuntimeCtxId& /*aRecipient*/, TInt /*aError*/)
+   	{
+   	// Anything to do?
+   	}
+
+TBool ESock::TCommsClientSideApiExt::IsSupported(TSupportedCommsApiExt aApiExtensionId)
+	{
+	const TInt KEndOfUidListSentinelUid = 0x102864E6;
+
+	const TSupportedCommsApiExt iList[] = 
+		{
+		EMobilityApiExt,
+		ELegacySubConnectionActiveApiExt,
+		EDataMonitoringApiExt,
+		ELegacyEnumerateSubConnectionsApiExt,
+		// End of list
+		(TSupportedCommsApiExt)KEndOfUidListSentinelUid
+		};
+
+	for(TInt index = 0; iList[index] != KEndOfUidListSentinelUid; index++)
+		{
+		if(iList[index] == aApiExtensionId)
+			{
+			return ETrue;
+			}
+		}
+	
+	return EFalse;
+	}
+
+//MZ: This current hard-coded routing (and closing) behaviour is not ideal.
+//We should migrate ESockSvr to the solution in Den,
+//where each session & subsession has its own API ext register
+//and closes all opened extension when going out of scope.
+void TCancelAndCloseAllClientExtItf::CancelCloseAllAndForwardMsgL(const TRuntimeCtxId& aSender, TSignalBase& aMessage, Messages::ANode& aNode)
+	{
+	NetInterfaces::TInterfaceControl* ic = aNode.FetchNodeInterfaceControlL(AMMNodeBase::KInterfaceId);
+	NetInterfaces::TInterfaceIter itfIter(*ic);
+
+	TCommsApiExtRegister& itfRegister = SockManGlobals::Get()->iCommsApiExtRegister;
+	TAny* itf = itfIter[0];
+
+	while(itf)
+		{
+		TInt itfId = itfIter.ItfId();
+
+		if(TCommsClientSideApiExt::IsSupported((TSupportedCommsApiExt)itfId))
+			{
+			AExtensionInterfaceThickBase& baseItf = *static_cast<AExtensionInterfaceThickBase*>(itf);
+			if (iClientId!=0)
+				{
+				baseItf.CancelExtensionInterface(iClientId);
+				baseItf.CloseExtensionInterface(iClientId);
+				itfRegister.DeRegisterInterface(itfId, iClientId);
+				}
+			else
+				{
+				//TCommsApiExtRegisterClientIter clientIter(itfId, itfRegister);
+				TUint client = itfRegister.FirstClient(itfId);
+				while (client!=0)
+					{
+					baseItf.CancelExtensionInterface(client);
+					baseItf.CloseExtensionInterface(client);
+					client = itfRegister.DeRegisterInterface(itfId, client);
+					}
+				}
+			}
+		itf = itfIter++;
+		}
+	ForwardMessageL(aSender, aMessage, aNode);
+	}
+
+DEFINE_MVIP_CTR(TCancelAndCloseAllClientExtItf)
+
+START_ATTRIBUTE_TABLE(TCancelAndCloseAllClientExtItf, KExtItfMsgImplementationUid, ECancelAndCloseAllClientExtItf)
+	REGISTER_ATTRIBUTE(TCancelAndCloseAllClientExtItf, iClientId, TMeta<TUint>)
+END_ATTRIBUTE_TABLE()
+
+// ----- TApiExtMsgDispatcher -----
+
+void TApiExtMsgDispatcher::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)
+	{
+	const TNodeId& nodeId = address_cast<const TNodeId>(aRecipient);
+	NetInterfaces::TInterfaceControl* tic = FetchInterfaceControlOrForwardMsgL(aSender, *this, nodeId.Node(), iResponseMsg.InterfaceId());
+
+	if (tic)
+	    {
+		TBuf8<KMaxExtApiIpcMsgLength> msgDst;
+		TCommsApiExtReqMsg* msg = static_cast<TCommsApiExtReqMsg*>(iResponseMsg.ReadClientReqMsg(msgDst));
+		User::LeaveIfError(msg? KErrNone : KErrNotSupported);
+		//TODO: ASSERT(msg->IsTypeOf(TCommsApiExtReqMsg::TypeId()));
+		msg->DispatchL(*tic, iClientId, iResponseMsg);
+	    }
+	}
+
+void TApiExtMsgDispatcher::Error(const TRuntimeCtxId& /*aSender*/, const TRuntimeCtxId& /*aRecipient*/, TInt aError)
+   	{
+   	if (aError==KErrNotFound)
+   		{
+   		//This IPC call has not been served.
+   		aError=KErrNotSupported;
+   		}
+
+   	iResponseMsg.Complete(aError);
+   	}
+
+DEFINE_MVIP_CTR(TApiExtMsgDispatcher)
+
+START_ATTRIBUTE_TABLE(TApiExtMsgDispatcher, KExtItfMsgImplementationUid, EApiExtMsgDispatcher)
+	REGISTER_ATTRIBUTE(TApiExtMsgDispatcher, iClientId, TMeta<TUint>)
+	REGISTER_ATTRIBUTE(TApiExtMsgDispatcher, iResponseMsg, TMeta<Elements::RResponseMsg>)
+END_ATTRIBUTE_TABLE()
+
+const TImplementationProxy ExtItfMsgImplementationTable[] =
+	{
+	MVIP_CTR_ENTRY(EApiExtMsgDispatcher, TApiExtMsgDispatcher),
+	MVIP_CTR_ENTRY(EOpenExtensionInterface, TOpenExtensionInterface),
+	MVIP_CTR_ENTRY(ECloseExtensionInterface, TCloseExtensionInterface),
+	MVIP_CTR_ENTRY(ECancelAndCloseAllClientExtItf, TCancelAndCloseAllClientExtItf)
+	};
+
+void TExtItfMsgTables::RegisterL()
+	{
+	TlsGlobals::Get().RegisterInterfaceL(TUid::Uid(KExtItfMsgImplementationUid), sizeof(ExtItfMsgImplementationTable) / sizeof(ExtItfMsgImplementationTable[0]), ExtItfMsgImplementationTable);
+	}
+
+void TExtItfMsgTables::DeRegister()
+	{
+	TlsGlobals::Get().DeregisterInterface(TUid::Uid(KExtItfMsgImplementationUid));
+	}
+
+
+
+