--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/ssock/ss_nodemessages.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,767 @@
+// 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
+*/
+
+#define SYMBIAN_NETWORKING_UPS
+#include "ss_nodemessages.h"
+
+
+#include <comms-infras/ss_log.h>
+#include <ss_fact.h>
+#include <comms-infras/ss_mcprnodemessages.h>
+#include "ss_flowrequest.h"
+#include <comms-infras/ss_corepractivities.h>
+#include "ss_transporthook.h"
+#include <elements/metatype.h>
+#include <elements/sm_core.h>
+#include <ss_glob.h>
+#include <comms-infras/ss_nodeinterfaces.h>
+#include <comms-infras/ss_thread.h>
+#include <comms-infras/ss_commsdataobject.h>
+#include <elements/interfacetable.h>
+#include <es_panic.h>
+#include <es_sock.h>
+#include <comms-infras/ss_connprov.h>
+#include <comms-infras/ss_subconnprov.h>
+#include <comms-infras/ss_subconnflow.h>
+#include <comms-infras/ss_protflow.h>
+
+#include <elements/cftransportmsg.h>
+#include <elements/nm_messages_child.h>
+#include <addressupdate.h>
+
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <es_panic_internal.h>
+#endif
+
+#include "ss_nodemessages_dataclient.h"
+#include <comms-infras/ss_nodemessages_internal.h>
+
+#ifdef SYMBIAN_NETWORKING_UPS
+#include <comms-infras/ss_upsaccesspointconfigext.h>
+#endif
+
+#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_ESockSSocksndmsg, "ESockSSocksndmsg");
+#endif
+
+
+using namespace ESock;
+using namespace Elements;
+using namespace Meta;
+using namespace Messages;
+
+// Ugly hack: mingw does not evaulate macros early enough to pass as template arguments so we hard code the
+// value for the x86gcc platform.  A compile time assertion ensures that the value stays correct.
+#ifdef __X86GCC__
+	#define KOffsetTSigUidFactoryQuery_iQuery	24
+#else
+	#define KOffsetTSigUidFactoryQuery_iQuery	( _FOFF(TSigPlayerRoleUidFactoryQuery, iQuery) )
+#endif
+
+__ASSERT_COMPILE( KOffsetTSigUidFactoryQuery_iQuery == _FOFF(TSigPlayerRoleUidFactoryQuery, iQuery) );
+
+using namespace Factories;
+
+//We can safely reuse this UID for singature's TIDs (but they mean different things)
+const TInt KESockInternalMessagesImplementationUid = TCFMessage::ERealmId;
+
+enum EMessageTypeId //message signatures only (NOT messages) messages are declared under class TCFMessage
+	{
+	//  spare                       =1,
+    //	spare						=2,
+	ESignatureSigAddrUpdate			=3,
+	ESignatureConnectionInfo		=4,
+	ESignatureProvisionConfig		=5,
+	ESignatureSelectionPrefs		=6,
+	ESignatureSelectComplete		=7,
+	ESignaturePlaneNotification		=8,
+
+	ESignatureSubConnNotification	=9,
+	ESignatureSubConnOpenedEvent	=10,
+	ESignatureSubConnClosedEvent	=11,
+	ESignatureStateChange			=12,
+
+	ESignatureUidFactoryQuery		=13,
+	ESignatureBundleRMessage2		=14,
+	ESignatureBundle				=15,
+	ESignatureAvailabilitySubscriptionOptions = 16,
+	ESignatureAvailabilityStatus    = 17,
+	ESignatureNodeIdClientTypeNumber = 18,
+
+//	spare							=37,
+//	spare							=38,
+//	spare							=39,
+
+	//ESignatureNumberSubConnParams	=44,
+
+	ESignatureFlowParams				=45,
+	ESignatureConnPrefList 				= 46,
+	ESignatureUpsParameters 			= 47,	
+	ESignatureFamilyBundle			=48,
+	ESignatureNumberFamilyBundle	=49,
+	ESignatureUpsStatusChange 		=50,
+	ESignatureMetaExtContainer      =51,
+	ESignatureConnectionInfoPtr     =52,
+
+	EFlowRequestBase				=1000,
+	EImplicitFlowRequest			=1001,
+	EConnFlowRequest				=1002,
+	ESubConnFlowRequest				=1003,
+	EReBindLayerRequest				=1004,
+	EDataClientJoiningRequest       =1005,
+	EGetOrSetParameters				=1006,
+	EAlwaysFindFactoryQuery			=1007,
+	EMetaConnectionFactoryQuery		=1008,
+	EDefaultConnectionFactoryQuery	=1009,	
+	EDefaultSCPRFactoryQuery		=1010,
+	EDefaultFlowFactoryQuery		=1011,
+	EDefaultProtocolIntfFactoryQuery =1012,	
+	};
+
+//no need to serialise return value
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSubConNotification, KESockInternalMessagesImplementationUid, ESignatureSubConnNotification )
+	REGISTER_ATTRIBUTE( TSigSubConNotification, iRefCountOwnedSubConNotification, TMeta<CRefCountOwnedSubConNotification*> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigPlaneNotification, KESockInternalMessagesImplementationUid, ESignaturePlaneNotification )
+	REGISTER_ATTRIBUTE( TSigPlaneNotification, iRefCountOwnedNotification, TMeta<CRefCountOwnedNotification*> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSubConnOpenedEvent, KESockInternalMessagesImplementationUid, ESignatureSubConnOpenedEvent )
+	REGISTER_ATTRIBUTE( TSigSubConnOpenedEvent, iSubConnectionOpenedEvent, TMeta<TSubConnectionOpenedEvent> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSubConnClosedEvent, KESockInternalMessagesImplementationUid, ESignatureSubConnClosedEvent )
+	REGISTER_ATTRIBUTE( TSigSubConnClosedEvent, iSubConnectionClosedEvent, TMeta<TSubConnectionClosedEvent> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigPlayerRoleUidFactoryQuery, KESockInternalMessagesImplementationUid, ESignatureUidFactoryQuery )
+	REGISTER_ATTRIBUTE(TSigPlayerRoleUidFactoryQuery, iQuery, TMetaHandler )
+END_ATTRIBUTE_TABLE()
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigAddrUpdate, KESockInternalMessagesImplementationUid, ESignatureSigAddrUpdate )
+	REGISTER_ATTRIBUTE( TSigAddrUpdate, iAddrUpdate, TMeta<TAddrUpdate> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigConnectionInfo, KESockInternalMessagesImplementationUid, ESignatureConnectionInfo )
+	REGISTER_ATTRIBUTE( TSigConnectionInfo, iConnectionInfo, TMeta<TConnectionInfo> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSelectionPrefs, KESockInternalMessagesImplementationUid, ESignatureSelectionPrefs )
+	REGISTER_ATTRIBUTE( TSigSelectionPrefs, iSelectionPrefs, TMetaObject<TSelectionPrefs> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigConnPrefList, KESockInternalMessagesImplementationUid, ESignatureConnPrefList)
+	REGISTER_ATTRIBUTE( TSigConnPrefList, iConnPrefList, TMeta<RConnPrefList> )
+END_ATTRIBUTE_TABLE_BASE( Messages::TSignatureBase, ESignatureVoid )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSelectComplete, KESockInternalMessagesImplementationUid, ESignatureSelectComplete )
+	REGISTER_ATTRIBUTE( TSigSelectComplete, iNodeId, TMeta<TNodeId> )
+	REGISTER_ATTRIBUTE( TSigSelectComplete, iProviderInfo, TMeta<TProviderInfo> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigBundleRMessage2, KESockInternalMessagesImplementationUid, ESignatureBundleRMessage2 )
+	REGISTER_ATTRIBUTE( TSigBundleRMessage2, iBundle, TMeta<TAny*> )
+	REGISTER_ATTRIBUTE( TSigBundleRMessage2, iMessage, TMeta<RMessage2*> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigBundle, KESockInternalMessagesImplementationUid, ESignatureBundle )
+	REGISTER_ATTRIBUTE( TSigBundle, iBundle, TMeta<TAny*> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigFlowParams, KESockInternalMessagesImplementationUid, ESignatureFlowParams )
+	REGISTER_ATTRIBUTE( TSigFlowParams, iFlowParams, TMeta<TFlowParams> )
+END_ATTRIBUTE_TABLE_BASE( Messages::TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigAvailabilitySubscriptionOptions, KESockInternalMessagesImplementationUid, ESignatureAvailabilitySubscriptionOptions )
+	REGISTER_ATTRIBUTE( TSigAvailabilitySubscriptionOptions, iAvailabilitySubscriptionOptions, TMeta<TAvailabilitySubscriptionOptions> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigAvailabilityStatus, KESockInternalMessagesImplementationUid, ESignatureAvailabilityStatus )
+	REGISTER_ATTRIBUTE( TSigAvailabilityStatus, iAvailabilityStatus, TMeta<TAvailabilityStatus> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdClientTypeNumber, KESockInternalMessagesImplementationUid, ESignatureNodeIdClientTypeNumber )
+	REGISTER_ATTRIBUTE( TSigNodeIdClientTypeNumber, iNodeId, TMeta<TNodeId> )
+	REGISTER_ATTRIBUTE( TSigNodeIdClientTypeNumber, iClientType, TMeta<TClientType> )
+	REGISTER_ATTRIBUTE( TSigNodeIdClientTypeNumber, iValue, TMeta<TUint> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigFamilyBundle, KESockInternalMessagesImplementationUid, ESignatureFamilyBundle )
+	REGISTER_ATTRIBUTE( TSigFamilyBundle, iFamilyBundle, TMeta<RCFParameterFamilyBundleC> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNumberFamilyBundle, KESockInternalMessagesImplementationUid, ESignatureNumberFamilyBundle )
+	REGISTER_ATTRIBUTE( TSigNumberFamilyBundle, iValue, TMetaNumber )
+	REGISTER_ATTRIBUTE( TSigNumberFamilyBundle, iFamilyBundle, TMeta<RCFParameterFamilyBundleC> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureVoid )
+
+START_ATTRIBUTE_TABLE( TCFFlowRequestBase, KESockInternalMessagesImplementationUid, EFlowRequestBase )
+	REGISTER_ATTRIBUTE( TCFFlowRequestBase, iSubSessionUniqueId, TMetaNumber )
+ 	REGISTER_ATTRIBUTE( TCFFlowRequestBase, iFlowParams, TMeta<TFlowParams> )	
+END_ATTRIBUTE_TABLE_BASE( TSignalBase, ESignalBase )
+
+START_ATTRIBUTE_TABLE( TCFImplicitFlowRequest, KESockInternalMessagesImplementationUid, EImplicitFlowRequest )
+END_ATTRIBUTE_TABLE_BASE( TCFFlowRequestBase, EFlowRequestBase )
+
+START_ATTRIBUTE_TABLE( TCFConnFlowRequest, KESockInternalMessagesImplementationUid, EConnFlowRequest )
+	REGISTER_ATTRIBUTE( TCFConnFlowRequest, iSession, TMeta<TAny*> )
+	REGISTER_ATTRIBUTE( TCFConnFlowRequest, iHandle, TMetaNumber )
+END_ATTRIBUTE_TABLE_BASE( TCFFlowRequestBase, EFlowRequestBase )
+
+START_ATTRIBUTE_TABLE( TCFSubConnFlowRequest, KESockInternalMessagesImplementationUid, ESubConnFlowRequest )
+	REGISTER_ATTRIBUTE( TCFSubConnFlowRequest, iSession, TMeta<TAny*> )
+	REGISTER_ATTRIBUTE( TCFSubConnFlowRequest, iHandle, TMetaNumber )
+END_ATTRIBUTE_TABLE_BASE( TCFFlowRequestBase, EFlowRequestBase )
+
+START_ATTRIBUTE_TABLE( PRActivities::CRejoinDataClientActivity::TCFDataClientJoiningRequest, KESockInternalMessagesImplementationUid, EDataClientJoiningRequest )
+	REGISTER_ATTRIBUTE( PRActivities::CRejoinDataClientActivity::TCFDataClientJoiningRequest, iDataClient, TMeta<TNodeId> )
+	REGISTER_ATTRIBUTE( PRActivities::CRejoinDataClientActivity::TCFDataClientJoiningRequest, iDataClientType, TMeta<TClientType> )
+END_ATTRIBUTE_TABLE_BASE( TNodeSignal, ENodeSignal )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigStateChange, KESockInternalMessagesImplementationUid, ESignatureStateChange )
+	REGISTER_ATTRIBUTE( TSigStateChange, iStateChange, TMeta<TStateChange> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+#ifdef SYMBIAN_NETWORKING_UPS
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigUpsParameters, KESockInternalMessagesImplementationUid, ESignatureUpsParameters )
+	REGISTER_ATTRIBUTE( TSigUpsParameters, iParams, TMeta<TPolicyCheckRequestParams> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureVoid )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigUpsStatusChangeParameters, KESockInternalMessagesImplementationUid, ESignatureUpsStatusChange )
+	REGISTER_ATTRIBUTE( TSigUpsStatusChangeParameters, iParams, TMeta<TUPSStatusChangeParams> )
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureVoid )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN(CUPSAccessPointConfigExt, CUPSAccessPointConfigExt::EUPSAccessPointConfigUid, CUPSAccessPointConfigExt::ETypeId)
+// No attributes defined, as no serialisation takes place.
+END_ATTRIBUTE_TABLE()
+#endif //SYMBIAN_NETWORKING_UPS
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TAlwaysFindFactoryQuery, KESockInternalMessagesImplementationUid, EAlwaysFindFactoryQuery)	
+END_ATTRIBUTE_TABLE()
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TMetaConnectionFactoryQuery, KESockInternalMessagesImplementationUid, EMetaConnectionFactoryQuery)	
+	REGISTER_ATTRIBUTE(TMetaConnectionFactoryQuery, iProviderInfo, TMeta<TProviderInfo>)
+	REGISTER_ATTRIBUTE(TMetaConnectionFactoryQuery, iTierImplUid, TMeta<TUint>)  
+END_ATTRIBUTE_TABLE()
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDefaultConnectionFactoryQuery, KESockInternalMessagesImplementationUid, EDefaultConnectionFactoryQuery)	
+	REGISTER_ATTRIBUTE(TDefaultConnectionFactoryQuery, iMCprId, TMeta<TNodeId>)	
+END_ATTRIBUTE_TABLE()
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDefaultSCPRFactoryQuery, KESockInternalMessagesImplementationUid, EDefaultSCPRFactoryQuery)	
+	REGISTER_ATTRIBUTE(TDefaultSCPRFactoryQuery, iControlProvider, TMeta<TNodeId>)
+	REGISTER_ATTRIBUTE(TDefaultSCPRFactoryQuery, iSCPRType, TMeta<TSubConnOpen::TSubConnType>)
+END_ATTRIBUTE_TABLE()
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDefaultFlowFactoryQuery, KESockInternalMessagesImplementationUid, EDefaultFlowFactoryQuery)	
+	REGISTER_ATTRIBUTE(TDefaultFlowFactoryQuery, iCprId, TMeta<TNodeId>)
+	REGISTER_ATTRIBUTE(TDefaultFlowFactoryQuery, iSCprId, TMeta<TNodeId>)
+	REGISTER_ATTRIBUTE(TDefaultFlowFactoryQuery, iMessageId, TMeta<TNodeSignal::TMessageId>)
+	REGISTER_ATTRIBUTE(TDefaultFlowFactoryQuery, iProtocolType, TMeta<TSubConnOpen::TSubConnType>)
+END_ATTRIBUTE_TABLE()
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDefaultProtocolIntfFactoryQuery, KESockInternalMessagesImplementationUid, EDefaultProtocolIntfFactoryQuery)	
+	REGISTER_ATTRIBUTE(TDefaultProtocolIntfFactoryQuery, iCprId, TMeta<TNodeId>)
+END_ATTRIBUTE_TABLE()
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigMetaExtContainer, KESockInternalMessagesImplementationUid, ESignatureMetaExtContainer )
+	{ _FOFF( TSigMetaExtContainer, iConfig ), ESock::TMetaExtensionContainerMetaType::NewL },
+END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase )
+
+EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigConnectionInfoPtr, KESockInternalMessagesImplementationUid, ESignatureConnectionInfoPtr )
+    REGISTER_ATTRIBUTE( TSigConnectionInfoPtr, iPtr, TMeta<CConnectionInfo*> )
+END_ATTRIBUTE_TABLE_BASE( Messages::TSignatureBase, ESignatureBase )
+
+
+DEFINE_MVIP_CTR(TSigStateChange);
+DEFINE_MVIP_CTR(TSigSelectionPrefs);
+DEFINE_MVIP_CTR(TSigConnPrefList);
+DEFINE_MVIP_CTR(TSigFlowParams);
+DEFINE_MVIP_CTR(TSigSubConNotification);
+DEFINE_MVIP_CTR(TSigPlaneNotification);
+DEFINE_MVIP_CTR(TSigSubConnOpenedEvent);
+DEFINE_MVIP_CTR(TSigSubConnClosedEvent);
+DEFINE_MVIP_CTR(TSigAddrUpdate);
+DEFINE_MVIP_CTR(TSigConnectionInfo);
+DEFINE_MVIP_CTR(TSigBundleRMessage2)
+DEFINE_MVIP_CTR(TSigBundle)
+DEFINE_MVIP_CTR(TSigSelectComplete)
+DEFINE_MVIP_CTR(TSigPlayerRoleUidFactoryQuery)
+DEFINE_MVIP_CTR(TSigAvailabilitySubscriptionOptions)
+DEFINE_MVIP_CTR(TSigAvailabilityStatus)
+DEFINE_MVIP_CTR(TSigNodeIdClientTypeNumber)
+DEFINE_MVIP_CTR(TSigMetaExtContainer)
+DEFINE_MVIP_CTR(TSigConnectionInfoPtr)
+
+#ifdef SYMBIAN_NETWORKING_UPS
+DEFINE_MVIP_CTR(TSigUpsParameters)
+DEFINE_MVIP_CTR(TSigUpsStatusChangeParameters)
+#endif
+
+DEFINE_MVIP_CTR(TSigFamilyBundle)
+DEFINE_MVIP_CTR(TSigNumberFamilyBundle)
+DEFINE_MVIP_CTR(TCFImplicitFlowRequest)
+DEFINE_MVIP_CTR(TCFConnFlowRequest)
+DEFINE_MVIP_CTR(TCFSubConnFlowRequest)
+
+DEFINE_MVIP_CTR(PRActivities::CRejoinDataClientActivity::TCFDataClientJoiningRequest)
+DEFINE_MVIP_CTR(TAlwaysFindFactoryQuery)
+DEFINE_MVIP_CTR(TMetaConnectionFactoryQuery)
+DEFINE_MVIP_CTR(TDefaultConnectionFactoryQuery)
+DEFINE_MVIP_CTR(TDefaultSCPRFactoryQuery)
+DEFINE_MVIP_CTR(TDefaultFlowFactoryQuery)
+DEFINE_MVIP_CTR(TDefaultProtocolIntfFactoryQuery)
+
+
+const TImplementationProxy SignatureImplementationTable[] =
+	{
+	//NOTE: Entries must be sorted for the binary search to work efficiently!
+	MVIP_CTR_ENTRY(ESignatureSigAddrUpdate,TSigAddrUpdate),				//14
+	MVIP_CTR_ENTRY(ESignatureConnectionInfo,TSigConnectionInfo),		//15
+	MVIP_CTR_ENTRY(ESignatureSelectionPrefs,TSigSelectionPrefs),		//18
+	MVIP_CTR_ENTRY(ESignatureSelectComplete,TSigSelectComplete),		//19
+	MVIP_CTR_ENTRY(ESignaturePlaneNotification,TSigPlaneNotification),	//20
+	MVIP_CTR_ENTRY(ESignatureSubConnNotification,TSigSubConNotification),	//21
+	MVIP_CTR_ENTRY(ESignatureSubConnOpenedEvent,TSigSubConnOpenedEvent), //22
+	MVIP_CTR_ENTRY(ESignatureSubConnClosedEvent,TSigSubConnClosedEvent), //23
+	MVIP_CTR_ENTRY(ESignatureStateChange,TSigStateChange),					//12
+	MVIP_CTR_ENTRY(ESignatureUidFactoryQuery,TSigPlayerRoleUidFactoryQuery),	//33
+	MVIP_CTR_ENTRY(ESignatureBundleRMessage2,TSigBundleRMessage2),		//40
+	MVIP_CTR_ENTRY(ESignatureBundle,TSigBundle),						//41
+	MVIP_CTR_ENTRY(ESignatureAvailabilitySubscriptionOptions,TSigAvailabilitySubscriptionOptions), //42
+	MVIP_CTR_ENTRY(ESignatureAvailabilityStatus,TSigAvailabilityStatus),//43
+	MVIP_CTR_ENTRY(ESignatureNodeIdClientTypeNumber, TSigNodeIdClientTypeNumber), //44
+	MVIP_CTR_ENTRY(ESignatureFlowParams,TSigFlowParams),	//45
+	MVIP_CTR_ENTRY(ESignatureConnPrefList,TSigConnPrefList),//46
+#ifdef SYMBIAN_NETWORKING_UPS
+	MVIP_CTR_ENTRY(ESignatureUpsParameters,TSigUpsParameters),//47
+#endif 	
+	MVIP_CTR_ENTRY(ESignatureFamilyBundle,TSigFamilyBundle),				//48
+	MVIP_CTR_ENTRY(ESignatureNumberFamilyBundle,TSigNumberFamilyBundle),	//49
+#ifdef SYMBIAN_NETWORKING_UPS
+	MVIP_CTR_ENTRY(ESignatureUpsStatusChange,TSigUpsStatusChangeParameters),//50
+#endif
+	MVIP_CTR_ENTRY(ESignatureMetaExtContainer,TSigMetaExtContainer),   //51
+	MVIP_CTR_ENTRY(ESignatureConnectionInfoPtr,TSigConnectionInfoPtr),   //52
+	MVIP_CTR_ENTRY(EImplicitFlowRequest,TCFImplicitFlowRequest),	    //1001
+	MVIP_CTR_ENTRY(EConnFlowRequest,TCFConnFlowRequest),			    //1002
+	MVIP_CTR_ENTRY(ESubConnFlowRequest,TCFSubConnFlowRequest),	        //1003
+	MVIP_CTR_ENTRY(EDataClientJoiningRequest,PRActivities::CRejoinDataClientActivity::TCFDataClientJoiningRequest),//1005
+	MVIP_CTR_ENTRY(EGetOrSetParameters,TGetOrSetParameters),				//1006
+	MVIP_CTR_ENTRY(EAlwaysFindFactoryQuery, TAlwaysFindFactoryQuery),	//1007
+	MVIP_CTR_ENTRY(EMetaConnectionFactoryQuery, TMetaConnectionFactoryQuery), //1008
+	MVIP_CTR_ENTRY(EDefaultConnectionFactoryQuery, TDefaultConnectionFactoryQuery), //1008	
+	MVIP_CTR_ENTRY(EDefaultSCPRFactoryQuery, TDefaultSCPRFactoryQuery), //1008	
+	MVIP_CTR_ENTRY(EDefaultFlowFactoryQuery, TDefaultFlowFactoryQuery),
+	MVIP_CTR_ENTRY(EDefaultProtocolIntfFactoryQuery, TDefaultProtocolIntfFactoryQuery),	
+	};
+
+
+void TCFMessage::RegisterL()
+	{
+	TlsGlobals::Get().RegisterInterfaceL(TUid::Uid(KESockInternalMessagesImplementationUid), sizeof(SignatureImplementationTable) / sizeof(SignatureImplementationTable[0]), SignatureImplementationTable);
+	}
+
+void TCFMessage::DeRegister()
+	{
+	TlsGlobals::Get().DeregisterInterface(TUid::Uid(KESockInternalMessagesImplementationUid));
+	}
+
+#if 0
+#ifdef ESOCK_EXTLOG_ACTIVE
+
+// for logging bundle
+#include <comms-infras/es_parameterbundle.h>
+
+TInt TNodeSignalBase::PrintableSignature(TDes8& aResult) const
+/**
+Generate printable output of signature parameters in the specified buffer
+
+@param aResult buffer to receive printable output.
+@return number of parameters output
+*/
+	{
+	_LIT8(KArgNumber, "%d");
+	_LIT8(KArgNumberNumber, "%d,%d");
+	_LIT8(KArgThreeNumbers, "%d,%d,%d");
+	_LIT8(KArgHexAndTwoDecimalNumbers, "%08x,%d,%d");
+#ifdef SYMBIAN_NETWORKING_UPS
+	_LIT8(KArgHexNumber, "%08x");
+#endif //SYMBIAN_NETWORKING_UPS
+
+	STypeId id = GetTypeId();
+	if (id.iUid.iUid == KESockInternalMessagesImplementationUid)
+		{
+		switch (id.iType)
+			{
+		case ESignatureNumber:
+			aResult.AppendFormat(KArgNumber(), static_cast<const TSigNumber*>(this)->iValue);
+			return 1;
+		case ESignatureStateChange:
+			{
+			const TStateChange& state = static_cast<const TSigStateChange*>(this)->iStateChange;
+			aResult.AppendFormat(KArgNumberNumber(), state.iStage, state.iError);
+			return 2;
+			}
+		case ESignatureNumberNumber:
+			{
+			const TSigNumberNumber* sig = static_cast<const TSigNumberNumber*>(this);
+			aResult.AppendFormat(KArgNumberNumber(), sig->iValue1, sig->iValue2);
+			return 2;
+			}
+		case ESignatureErrResponse:
+			{
+			const TErrResponse& resp = static_cast<const TSigErrResponse*>(this)->iErrResponse;
+			aResult.AppendFormat(KArgThreeNumbers(), resp.iAction, resp.iError, resp.iMessageId.MessageId());
+			return 3;
+			}
+		case ESignatureErrContext:
+			{
+			const TErrContext& ctx = static_cast<const TSigErrContext*>(this)->iErrContext;
+			aResult.AppendFormat(KArgHexAndTwoDecimalNumbers(), ctx.iOriginator.Printable(), ctx.iMessageId.MessageId(), ctx.iActivityId);
+			return 3;
+			}
+		case ESignatureMessageIdNumber:
+			{
+			const TSigMessageIdNumber* sig = static_cast<const TSigMessageIdNumber*>(this);
+#ifdef SYMBIAN_NETWORKING_UPS
+			_LIT8(KArgStringNumber, "%s,%d");
+			// TPrintableMessage is just for printing out a MessageId in human readable form.
+			class TPrintableMessage : public TCFSignatureBase
+				{
+			public:
+				TPrintableMessage(const TCFNodeSignalBase::TMessageId& aMessageId)
+				: TCFSignatureBase(aMessageId, *TCommsId::KNullCommsId, ECFActivityNull)
+					{
+					}
+				} msg(sig->iMsgId);
+			aResult.AppendFormat(KArgStringNumber(), msg.Printable(), sig->iValue);
+#else
+			aResult.AppendFormat(KArgNumberNumber(), sig->iMsgId.MessageId(), sig->iValue);
+#endif
+			return 2;
+			}
+#ifdef SYMBIAN_NETWORKING_UPS
+		case ESignatureCommsBinderNumber:
+			{
+			const TSigCommsBinderNumber* sig = static_cast<const TSigCommsBinderNumber*>(this);
+			aResult.AppendFormat(KArgHexNumber(), sig->iCommsBinder.iCommsId.Printable());
+			return 1;
+			}
+
+		case ESignatureCommsBinder:
+			{
+			const TSigCommsBinder* sig = static_cast<const TSigCommsBinder*>(this);
+			aResult.AppendFormat(KArgHexNumber(), sig->iCommsBinder.iCommsId.Printable());
+			return 1;
+			}
+		case ESignatureSelectComplete:
+			{
+			const TSigSelectComplete* sig = static_cast<const TSigSelectComplete*>(this);
+			aResult.AppendFormat(KArgHexNumber(), sig->iCommsId.Printable());
+			return 1;
+			}
+		case ESignatureCommsId:
+			{
+			const TSigCommsId* sig = static_cast<const TSigCommsId*>(this);
+			aResult.AppendFormat(KArgHexNumber(), sig->iCommsId.Printable());
+			return 1;
+			}
+#endif
+
+		case ESignatureBundle:
+			{
+			const TSigBundle* bun = static_cast<const TSigBundle*>(this);
+			aResult.AppendFormat(_L8("Bundle (PSCs:%d)"), bun->iBundle->Ptr()->CountParamSetContainers());
+			return 1;
+			}
+		case ESignatureFlowParams:
+			{
+			const TSigFlowParams* flowParams = static_cast<const TSigFlowParams*>(this);
+			aResult.AppendFormat(
+				_L8("Flow params: addrFamily:%d, protocol:%d, socketType:%d, flowRequest:%d"),
+				flowParams->iFlowParams.iAddrFamily,
+				flowParams->iFlowParams.iProtocol,
+				flowParams->iFlowParams.iSocketType,
+				flowParams->iFlowParams.iFlowRequestType);
+			return 4;
+			}
+		default:
+			break;
+			}
+		}
+	return 0;
+	}
+
+#endif
+#endif
+
+
+
+//-======================================================
+// TMessageSigMetaExtContainer
+//-======================================================
+
+EXPORT_C void TSigMetaExtContainer::DispatchL(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient)
+    {
+    Messages::TSignatureBase::DispatchL(aSender, aRecipient);
+    iConfig.Close();
+    }
+
+EXPORT_C void TSigMetaExtContainer::Error(const TRuntimeCtxId& aSender, const TRuntimeCtxId& aRecipient, TInt aError)
+    {
+    iConfig.Close();
+    Messages::TSignatureBase::Error(aSender, aRecipient, aError);
+    }
+
+//-======================================================
+//
+//
+// CRefCountOwnerBase methods
+//
+//
+//-======================================================
+EXPORT_C CRefCountOwnerBase::CRefCountOwnerBase(const TAny* aPtr)
+: iPtr(const_cast<TAny*>(aPtr)),
+  iRefCount(0)
+    {
+	LOG_NODE_CREATE(KCFNodeTag, CRefCountOwnerBase)
+    }
+
+EXPORT_C CRefCountOwnerBase::~CRefCountOwnerBase()
+    {
+	LOG_NODE_DESTROY(KCFNodeTag, CRefCountOwnerBase)
+    }
+
+EXPORT_C void CRefCountOwnerBase::Close()
+/*
+To be called by the message receiver when it's finished
+inspecting the pointer.
+*/
+    {
+    // LockedDec() returns the value prior to decrement
+    if (User::LockedDec(iRefCount) == 1)
+        {
+        // If this CRefCountOwnerBase was created in a higher priority thread than
+        // the release of the final reference is running in, the TCFDataClient::TStop
+        // can dispatch and delete this object almost immediately.
+
+        // DO NOT put any processing after this PostTo()
+        RClientInterface::OpenPostMessageClose(Id(), Id(),
+        	TCFDataClient::TStop(0).CRef());
+        }
+    }
+
+EXPORT_C void CRefCountOwnerBase::Open()
+/*
+To be called by the message sender each time the same
+pointer is sent away.
+*/
+    {
+#ifdef _DEBUG
+    if (!User::LockedInc(iRefCount) && iRefOpened)
+    	{
+    	// This panic means that the objects ref count has been decremented to zero
+    	// and an async deletion has been initiated. You are now trying to Open() a
+    	// new ref on this soon to be dead object. Dangling pointers maybe??
+    	User::Panic(KESockFaultPanic, EDeadObjectReused);
+    	}
+    iRefOpened = ETrue;
+#else
+    User::LockedInc(iRefCount);
+#endif
+    }
+
+EXPORT_C void CRefCountOwnerBase::ReceivedL(const TRuntimeCtxId& /*aSender*/, const TNodeId& /*aRecipient*/, TSignatureBase& aMessage)
+   	{
+	(void)aMessage;
+   	__ASSERT_DEBUG(aMessage.IsMessage<TCFDataClient::TStop>(), User::Panic(KSpecAssert_ESockSSocksndmsg, 1));
+//   	delete iPtr;
+	DeletePtr();
+   	iPtr = NULL;
+   	delete this;
+   	}
+
+EXPORT_C Meta::SMetaData* TVCFromSockManAttributeCreationPolicy::New(TPtrC8& aSrc, TPtr8& aDst)
+	{
+	CMetaDataVirtualCtorInPlace* vctr = SockManGlobals::Get()->SelfWorker()->TransportGlobals().VirtualCtor();
+	if (vctr ==NULL)
+		{
+		return NULL;
+		}
+	__ASSERT_DEBUG(aSrc.Length() >= sizeof(STypeId), User::Panic(KSpecAssert_ESockSSocksndmsg, 2)); //At least the type id must be present			
+	return vctr->New ( aSrc, aDst );
+	}
+
+
+
+EXPORT_C MFactoryQuery::TMatchResult TAlwaysFindFactoryQuery::Match(Factories::TFactoryObjectInfo& /* aObjectInfo */)
+	{
+	return MFactoryQuery::EMatch; //Return the first and only.			
+	}
+
+EXPORT_C TAlwaysFindFactoryQuery ::TAlwaysFindFactoryQuery ()
+	{
+		
+	}
+
+EXPORT_C TMetaConnectionFactoryQuery::TMetaConnectionFactoryQuery()
+	{
+		
+	}
+
+EXPORT_C TMetaConnectionFactoryQuery::TMetaConnectionFactoryQuery(const TProviderInfo& aProviderInfo,const TUid aTierImplUid)
+: iProviderInfo(aProviderInfo),iTierImplUid(aTierImplUid)
+	{
+		
+	}
+	
+EXPORT_C MFactoryQuery::TMatchResult TMetaConnectionFactoryQuery::Match(Factories::TFactoryObjectInfo& aFactoryObjectInfo)
+	{
+	CMetaConnectionProviderBase* prov = static_cast<CMetaConnectionProviderBase*>(aFactoryObjectInfo.iInfo.iFactoryObject);
+	return prov->ProviderInfo() == iProviderInfo? MFactoryQuery::EMatch : MFactoryQuery::EContinue;		
+	}
+
+EXPORT_C TDefaultConnectionFactoryQuery::TDefaultConnectionFactoryQuery(const Messages::TNodeId& aMCprId)
+: iMCprId(aMCprId)
+	{
+		
+	}
+
+EXPORT_C MFactoryQuery::TMatchResult TDefaultConnectionFactoryQuery::Match(Factories::TFactoryObjectInfo& aFactoryObjectInfo)
+	{
+	CConnectionProviderBase* prov = static_cast<CConnectionProviderBase*>(aFactoryObjectInfo.iInfo.iFactoryObject);
+
+	if (prov->ControlProvider())
+		{
+		// Each MCPR instance can only have one data client.  The comparison here uses the NodeId of the MCPR
+		// to implement this check.
+		//ASSERT(prov->ControlProvider());
+		return prov->ControlProvider()->RecipientId() == iMCprId ? MFactoryQuery::EMatch : MFactoryQuery::EContinue;
+		}
+	else
+		{
+		// This is to support the half-way house bluetooth code
+		// There is a dummy Cpr owning lower scpr's that are not
+		// created by the framework in the usual way.
+		// This dummy Cpr is also not created in the usual way
+		// and hence will not have a ControlProvider()
+		return MFactoryQuery::EContinue;
+		}		
+	}
+
+EXPORT_C TDefaultConnectionFactoryQuery::TDefaultConnectionFactoryQuery()
+: iMCprId(TNodeId::NullId())
+	{
+		
+	}
+
+EXPORT_C TDefaultSCPRFactoryQuery::TDefaultSCPRFactoryQuery()
+: iControlProvider(TNodeId::NullId()),
+iSCPRType((TSubConnOpen::TSubConnType)0)
+	{
+		
+	}
+
+//used to look up sub-connection from control side
+EXPORT_C TDefaultSCPRFactoryQuery::TDefaultSCPRFactoryQuery(const Messages::TNodeId& aControlProvider, TSubConnOpen::TSubConnType aSCPRType)
+: iControlProvider(aControlProvider),
+iSCPRType(aSCPRType)
+	{
+		
+	}
+
+EXPORT_C MFactoryQuery::TMatchResult TDefaultSCPRFactoryQuery::Match(Factories::TFactoryObjectInfo& aFactoryObjectInfo)
+	{
+	if (iSCPRType == TSubConnOpen::ECreateNew)
+    	{
+    	return MFactoryQuery::ECancel;
+    	}
+	CSubConnectionProviderBase* sc = static_cast<CSubConnectionProviderBase*>(aFactoryObjectInfo.iInfo.iFactoryObject);
+	MFactoryQuery::TMatchResult match = aFactoryObjectInfo.iInfo.iFlag == iSCPRType ? MFactoryQuery::EMatch : MFactoryQuery::EContinue;
+	__ASSERT_DEBUG(sc->ControlProvider(), User::Panic(KSpecAssert_ESockSSocksndmsg, 3));
+
+	if (match == MFactoryQuery::EMatch)
+	   	{
+    	match = iControlProvider == sc->ControlProvider()->RecipientId() ? MFactoryQuery::EMatch : MFactoryQuery::EContinue;
+    	}
+	return match;			
+	}
+
+EXPORT_C TDefaultFlowFactoryQuery::TDefaultFlowFactoryQuery()
+: iCprId(TNodeId::NullId()),
+iSCprId(TNodeId::NullId())
+	{
+		
+	}
+
+EXPORT_C TDefaultFlowFactoryQuery::TDefaultFlowFactoryQuery(const Messages::TNodeId& aSCprId)
+: iCprId(TNodeId::NullId()),
+iSCprId(aSCprId)
+	{
+		
+	}
+
+EXPORT_C TDefaultFlowFactoryQuery::TDefaultFlowFactoryQuery(const Messages::TNodeId& aCprId, const Messages::TNodeId& aSCprId, Messages::TNodeSignal::TMessageId aMessageId, TInt aProtocolType)
+: iCprId(aCprId),
+iSCprId(aSCprId),
+iMessageId(aMessageId),
+iProtocolType(aProtocolType)
+	{
+		
+	}
+
+EXPORT_C TDefaultFlowFactoryQuery::TDefaultFlowFactoryQuery(const Messages::TNodeId& aCprId, const Messages::TNodeId& aSCprId)
+: iCprId(aCprId),
+iSCprId(aSCprId)
+	{
+		
+	}
+
+EXPORT_C MFactoryQuery::TMatchResult TDefaultFlowFactoryQuery::Match(Factories::TFactoryObjectInfo& aFactoryObjectInfo)
+	{
+	CSubConnectionFlowBase* flow = static_cast<CSubConnectionFlowBase*>(aFactoryObjectInfo.iInfo.iFactoryObject);
+	if (flow->HasControlPlane() && flow->ControlProvider() == iSCprId)
+		{
+		return MFactoryQuery::EMatch;
+		}
+	return MFactoryQuery::EContinue;		
+	}
+
+EXPORT_C TDefaultProtocolIntfFactoryQuery::TDefaultProtocolIntfFactoryQuery()
+: iCprId(TNodeId::NullId())
+	{
+		
+	}
+
+EXPORT_C TDefaultProtocolIntfFactoryQuery::TDefaultProtocolIntfFactoryQuery(const Messages::TNodeId& aCprId)
+: iCprId(aCprId)
+	{
+		
+	}
+
+EXPORT_C MFactoryQuery::TMatchResult TDefaultProtocolIntfFactoryQuery::Match(Factories::TFactoryObjectInfo& aFactoryObjectInfo)
+	{
+	CProtocolIntfBase* protIntf = static_cast<CProtocolIntfBase*>(aFactoryObjectInfo.iInfo.iFactoryObject);
+	return (protIntf->ControlProviderId() == iCprId ? MFactoryQuery::EMatch : MFactoryQuery::EContinue);		
+	}
+