diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/ssock/ss_nodemessages.cpp --- /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 +#include +#include +#include "ss_flowrequest.h" +#include +#include "ss_transporthook.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif + +#include "ss_nodemessages_dataclient.h" +#include + +#ifdef SYMBIAN_NETWORKING_UPS +#include +#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 ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigPlaneNotification, KESockInternalMessagesImplementationUid, ESignaturePlaneNotification ) + REGISTER_ATTRIBUTE( TSigPlaneNotification, iRefCountOwnedNotification, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSubConnOpenedEvent, KESockInternalMessagesImplementationUid, ESignatureSubConnOpenedEvent ) + REGISTER_ATTRIBUTE( TSigSubConnOpenedEvent, iSubConnectionOpenedEvent, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSubConnClosedEvent, KESockInternalMessagesImplementationUid, ESignatureSubConnClosedEvent ) + REGISTER_ATTRIBUTE( TSigSubConnClosedEvent, iSubConnectionClosedEvent, TMeta ) +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 ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigConnectionInfo, KESockInternalMessagesImplementationUid, ESignatureConnectionInfo ) + REGISTER_ATTRIBUTE( TSigConnectionInfo, iConnectionInfo, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSelectionPrefs, KESockInternalMessagesImplementationUid, ESignatureSelectionPrefs ) + REGISTER_ATTRIBUTE( TSigSelectionPrefs, iSelectionPrefs, TMetaObject ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigConnPrefList, KESockInternalMessagesImplementationUid, ESignatureConnPrefList) + REGISTER_ATTRIBUTE( TSigConnPrefList, iConnPrefList, TMeta ) +END_ATTRIBUTE_TABLE_BASE( Messages::TSignatureBase, ESignatureVoid ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigSelectComplete, KESockInternalMessagesImplementationUid, ESignatureSelectComplete ) + REGISTER_ATTRIBUTE( TSigSelectComplete, iNodeId, TMeta ) + REGISTER_ATTRIBUTE( TSigSelectComplete, iProviderInfo, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigBundleRMessage2, KESockInternalMessagesImplementationUid, ESignatureBundleRMessage2 ) + REGISTER_ATTRIBUTE( TSigBundleRMessage2, iBundle, TMeta ) + REGISTER_ATTRIBUTE( TSigBundleRMessage2, iMessage, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigBundle, KESockInternalMessagesImplementationUid, ESignatureBundle ) + REGISTER_ATTRIBUTE( TSigBundle, iBundle, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigFlowParams, KESockInternalMessagesImplementationUid, ESignatureFlowParams ) + REGISTER_ATTRIBUTE( TSigFlowParams, iFlowParams, TMeta ) +END_ATTRIBUTE_TABLE_BASE( Messages::TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigAvailabilitySubscriptionOptions, KESockInternalMessagesImplementationUid, ESignatureAvailabilitySubscriptionOptions ) + REGISTER_ATTRIBUTE( TSigAvailabilitySubscriptionOptions, iAvailabilitySubscriptionOptions, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigAvailabilityStatus, KESockInternalMessagesImplementationUid, ESignatureAvailabilityStatus ) + REGISTER_ATTRIBUTE( TSigAvailabilityStatus, iAvailabilityStatus, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigNodeIdClientTypeNumber, KESockInternalMessagesImplementationUid, ESignatureNodeIdClientTypeNumber ) + REGISTER_ATTRIBUTE( TSigNodeIdClientTypeNumber, iNodeId, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdClientTypeNumber, iClientType, TMeta ) + REGISTER_ATTRIBUTE( TSigNodeIdClientTypeNumber, iValue, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigFamilyBundle, KESockInternalMessagesImplementationUid, ESignatureFamilyBundle ) + REGISTER_ATTRIBUTE( TSigFamilyBundle, iFamilyBundle, TMeta ) +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 ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureVoid ) + +START_ATTRIBUTE_TABLE( TCFFlowRequestBase, KESockInternalMessagesImplementationUid, EFlowRequestBase ) + REGISTER_ATTRIBUTE( TCFFlowRequestBase, iSubSessionUniqueId, TMetaNumber ) + REGISTER_ATTRIBUTE( TCFFlowRequestBase, iFlowParams, TMeta ) +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 ) + REGISTER_ATTRIBUTE( TCFConnFlowRequest, iHandle, TMetaNumber ) +END_ATTRIBUTE_TABLE_BASE( TCFFlowRequestBase, EFlowRequestBase ) + +START_ATTRIBUTE_TABLE( TCFSubConnFlowRequest, KESockInternalMessagesImplementationUid, ESubConnFlowRequest ) + REGISTER_ATTRIBUTE( TCFSubConnFlowRequest, iSession, TMeta ) + 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 ) + REGISTER_ATTRIBUTE( PRActivities::CRejoinDataClientActivity::TCFDataClientJoiningRequest, iDataClientType, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TNodeSignal, ENodeSignal ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigStateChange, KESockInternalMessagesImplementationUid, ESignatureStateChange ) + REGISTER_ATTRIBUTE( TSigStateChange, iStateChange, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureBase ) + +#ifdef SYMBIAN_NETWORKING_UPS +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigUpsParameters, KESockInternalMessagesImplementationUid, ESignatureUpsParameters ) + REGISTER_ATTRIBUTE( TSigUpsParameters, iParams, TMeta ) +END_ATTRIBUTE_TABLE_BASE( TSignatureBase, ESignatureVoid ) + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN( TSigUpsStatusChangeParameters, KESockInternalMessagesImplementationUid, ESignatureUpsStatusChange ) + REGISTER_ATTRIBUTE( TSigUpsStatusChangeParameters, iParams, TMeta ) +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) + REGISTER_ATTRIBUTE(TMetaConnectionFactoryQuery, iTierImplUid, TMeta) +END_ATTRIBUTE_TABLE() + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDefaultConnectionFactoryQuery, KESockInternalMessagesImplementationUid, EDefaultConnectionFactoryQuery) + REGISTER_ATTRIBUTE(TDefaultConnectionFactoryQuery, iMCprId, TMeta) +END_ATTRIBUTE_TABLE() + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDefaultSCPRFactoryQuery, KESockInternalMessagesImplementationUid, EDefaultSCPRFactoryQuery) + REGISTER_ATTRIBUTE(TDefaultSCPRFactoryQuery, iControlProvider, TMeta) + REGISTER_ATTRIBUTE(TDefaultSCPRFactoryQuery, iSCPRType, TMeta) +END_ATTRIBUTE_TABLE() + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDefaultFlowFactoryQuery, KESockInternalMessagesImplementationUid, EDefaultFlowFactoryQuery) + REGISTER_ATTRIBUTE(TDefaultFlowFactoryQuery, iCprId, TMeta) + REGISTER_ATTRIBUTE(TDefaultFlowFactoryQuery, iSCprId, TMeta) + REGISTER_ATTRIBUTE(TDefaultFlowFactoryQuery, iMessageId, TMeta) + REGISTER_ATTRIBUTE(TDefaultFlowFactoryQuery, iProtocolType, TMeta) +END_ATTRIBUTE_TABLE() + +EXPORT_START_ATTRIBUTE_TABLE_AND_FN(TDefaultProtocolIntfFactoryQuery, KESockInternalMessagesImplementationUid, EDefaultProtocolIntfFactoryQuery) + REGISTER_ATTRIBUTE(TDefaultProtocolIntfFactoryQuery, iCprId, TMeta) +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 ) +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 + +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(this)->iValue); + return 1; + case ESignatureStateChange: + { + const TStateChange& state = static_cast(this)->iStateChange; + aResult.AppendFormat(KArgNumberNumber(), state.iStage, state.iError); + return 2; + } + case ESignatureNumberNumber: + { + const TSigNumberNumber* sig = static_cast(this); + aResult.AppendFormat(KArgNumberNumber(), sig->iValue1, sig->iValue2); + return 2; + } + case ESignatureErrResponse: + { + const TErrResponse& resp = static_cast(this)->iErrResponse; + aResult.AppendFormat(KArgThreeNumbers(), resp.iAction, resp.iError, resp.iMessageId.MessageId()); + return 3; + } + case ESignatureErrContext: + { + const TErrContext& ctx = static_cast(this)->iErrContext; + aResult.AppendFormat(KArgHexAndTwoDecimalNumbers(), ctx.iOriginator.Printable(), ctx.iMessageId.MessageId(), ctx.iActivityId); + return 3; + } + case ESignatureMessageIdNumber: + { + const TSigMessageIdNumber* sig = static_cast(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(this); + aResult.AppendFormat(KArgHexNumber(), sig->iCommsBinder.iCommsId.Printable()); + return 1; + } + + case ESignatureCommsBinder: + { + const TSigCommsBinder* sig = static_cast(this); + aResult.AppendFormat(KArgHexNumber(), sig->iCommsBinder.iCommsId.Printable()); + return 1; + } + case ESignatureSelectComplete: + { + const TSigSelectComplete* sig = static_cast(this); + aResult.AppendFormat(KArgHexNumber(), sig->iCommsId.Printable()); + return 1; + } + case ESignatureCommsId: + { + const TSigCommsId* sig = static_cast(this); + aResult.AppendFormat(KArgHexNumber(), sig->iCommsId.Printable()); + return 1; + } +#endif + + case ESignatureBundle: + { + const TSigBundle* bun = static_cast(this); + aResult.AppendFormat(_L8("Bundle (PSCs:%d)"), bun->iBundle->Ptr()->CountParamSetContainers()); + return 1; + } + case ESignatureFlowParams: + { + const TSigFlowParams* flowParams = static_cast(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(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(), 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(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(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(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(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(aFactoryObjectInfo.iInfo.iFactoryObject); + return (protIntf->ControlProviderId() == iCprId ? MFactoryQuery::EMatch : MFactoryQuery::EContinue); + } +