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

//-======================================================