diff -r 000000000000 -r dfb7c4ff071f commsinfrastructureapitest/commsinfrastructuresvs/suite/common/src/T_DataCommsBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commsinfrastructureapitest/commsinfrastructuresvs/suite/common/src/T_DataCommsBase.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,2141 @@ +/* +* 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: +* +*/ + +#include "T_DataCommsBase.h" + +// Epoc includes +#include +#include +#include +#include +#include + +/*@{*/ +/// Constant Literals used. +_LIT(KInterfaceDownBuf, "EInterfaceDown"); + +// TConnectionType +_LIT(KConnectionCSD , "EConnectionCSD "); +_LIT(KConnectionGPRS, "EConnectionGPRS"); +_LIT(KConnectionGPRSR97, "EConnectionGPRSR97"); +_LIT(KConnectionGPRSR99, "EConnectionGPRSR99"); +_LIT(KConnectionGPRSRel4, "EConnectionGPRSRel4"); +_LIT(KConnectionGPRSRel5, "EConnectionGPRSRel5"); +//_LIT(KConnectionCDMA, "EConnectionCDMA"); +//_LIT(KConnectionCDMA20001xRTT, "EConnectionCDMA20001xRTT"); +//_LIT(KConnectionCDMA20001xRTTDO, "EConnectionCDMA20001xRTTDO "); +//_LIT(KConnectionCDMA20001xRTTDV, "EConnectionCDMA20001xRTTDV"); +//_LIT(KConnectionCDMA20003xRTT, "EConnectionCDMA20003xRTT"); +_LIT(KConnectionEthernet, "EConnectionEthernet"); +_LIT(KConnectionWLAN, "EConnectionWLAN"); +_LIT(KConnectionBTPAN, "EConnectionBTPAN"); + +// TConnStopType +_LIT(KStopAuthoritative, "EStopAuthoritative"); + +// TConnAttachType +_LIT(KAttachTypeMonitor, "EAttachTypeMonitor"); + +// SockType +_LIT(KSockStreamStr, "KSockStream"); +_LIT(KSockDatagramStr, "KSockDatagram"); + +// Protocol +_LIT(KProtocolInetTcpStr, "KProtocolInetTcp"); +_LIT(KProtocolInetUdpStr, "KProtocolInetUdp"); + +// AddrFamily +_LIT(KAFUnspecStr, "KAFUnspec"); +_LIT(KAfInetStr, "KAfInet"); +_LIT(KAfInet6Str, "KAfInet6"); + +// Capability +_LIT(ECapabilityTCBStr, "ECapabilityTCB"); +_LIT(ECapabilityCommDDStr, "ECapabilityCommDD"); +_LIT(ECapabilityPowerMgmtStr, "ECapabilityPowerMgmt"); +_LIT(ECapabilityMultimediaDDStr, "ECapabilityMultimediaDD"); +_LIT(ECapabilityReadDeviceDataStr, "ECapabilityReadDeviceData"); +_LIT(ECapabilityWriteDeviceDataStr, "ECapabilityWriteDeviceData"); +_LIT(ECapabilityDRMStr, "ECapabilityDRM"); +_LIT(ECapabilityTrustedUIStr, "ECapabilityTrustedUI"); +_LIT(ECapabilityProtServStr, "ECapabilityProtServ"); +_LIT(ECapabilityDiskAdminStr, "ECapabilityDiskAdmin"); +_LIT(ECapabilityNetworkControlStr, "ECapabilityNetworkControl"); +_LIT(ECapabilityAllFilesStr, "ECapabilityAllFiles"); +_LIT(ECapabilitySwEventStr, "ECapabilitySwEvent"); +_LIT(ECapabilityNetworkServicesStr, "ECapabilityNetworkServices"); +_LIT(ECapabilityLocalServicesStr, "ECapabilityLocalServices"); +_LIT(ECapabilityReadUserDataStr, "ECapabilityReadUserData"); +_LIT(ECapabilityWriteUserDataStr, "ECapabilityWriteUserData"); +_LIT(ECapabilityLocationStr, "ECapabilityLocation"); +_LIT(ECapabilitySurroundingsDDStr, "ECapabilitySurroundingsDD"); +_LIT(ECapabilityUserEnvironmentStr, "ECapabilityUserEnvironment"); +_LIT(ECapability_LimitStr, "ECapability_Limit"); +_LIT(ECapability_HardLimitStr, "ECapability_HardLimit"); +_LIT(ECapability_NoneStr, "ECapability_None"); +_LIT(ECapability_DeniedStr, "ECapability_Denied"); + +// ProgressNotification stages +_LIT(KStartingSelectionStr, "KStartingSelection"); +_LIT(KFinishedSelectionStr, "KFinishedSelection"); +_LIT(KConnectionOpenStr, "KConnectionOpen"); +_LIT(KLinkLayerOpenStr, "KLinkLayerOpen"); +_LIT(KLinkLayerClosedStr, "KLinkLayerClosed"); +_LIT(KNonExistentStr, "KNonExistent"); + +// TSubConnType +_LIT(KCreateNew, "ECreateNew"); +_LIT(KAttachToDefault, "EAttachToDefault"); + +// EventGroupUid +_LIT(KSubConnGenericEventsImplUidStr, "KSubConnGenericEventsImplUid"); + +// EventNotification events +_LIT(KSubConGenericEventParamsGrantedStr, "KSubConGenericEventParamsGranted"); +_LIT(KSubConGenericEventDataClientJoinedStr, "KSubConGenericEventDataClientJoined"); +_LIT(KSubConGenericEventDataClientLeftStr, "KSubConGenericEventDataClientLeft"); +_LIT(KSubConGenericEventSubConDownStr, "KSubConGenericEventSubConDown"); +_LIT(KSubConGenericEventParamsChangedStr, "KSubConGenericEventParamsChanged"); +_LIT(KSubConGenericEventParamsRejectedStr, "KSubConGenericEventParamsRejected"); + +// ParameterSetType + +_LIT(KAcceptable, "EAcceptable"); +_LIT(KRequested, "ERequested"); +_LIT(KGranted, "EGranted"); +/*@}*/ + + +CT_DataCommsBase::CT_DataCommsBase() + { + } + +CT_DataCommsBase::~CT_DataCommsBase() + { + } + +void CT_DataCommsBase::RunL( CActive* aActive, TInt /*aIndex*/ ) + { + ERR_PRINTF2(_L("RunL Stray signal, status = %d"), aActive->iStatus.Int()); + SetBlockResult(EFail); + } + +void CT_DataCommsBase::DoCancel( CActive* aActive, TInt /*aIndex*/ ) + { + ERR_PRINTF2(_L("DoCancel Stray signal, status = %d"), aActive->iStatus.Int()); + SetBlockResult(EFail); + } + +void CT_DataCommsBase::MissingParamError( const TDesC& aParamName ) + { + ERR_PRINTF2(_L("No %S"), &aParamName); + SetBlockResult(EFail); + } + +TConnInterfaceState CT_DataCommsBase::InterfaceNotificationState( const TDesC& aState ) + { + TConnInterfaceState state = EInterfaceUp; + if( aState == KInterfaceDownBuf() ) + { + state = EInterfaceDown; + } + return state; + } + +TConnectionType CT_DataCommsBase::ConnectionType( const TDesC& aConnectionTypeName ) + { + TConnectionType connType = EConnectionGeneric; + if( aConnectionTypeName == KConnectionCSD() ) + { + connType = EConnectionCSD; + } + else if( aConnectionTypeName == KConnectionGPRS() ) + { + connType = EConnectionGPRS; + } + else if( aConnectionTypeName == KConnectionGPRSR97() ) + { + connType = EConnectionGPRSR97; + } + else if( aConnectionTypeName == KConnectionGPRSR99() ) + { + connType = EConnectionGPRSR99; + } + else if( aConnectionTypeName == KConnectionGPRSRel4() ) + { + connType = EConnectionGPRSRel4; + } + else if( aConnectionTypeName == KConnectionGPRSRel5() ) + { + connType = EConnectionGPRSRel5; + } +/* else if( aConnectionTypeName == KConnectionCDMA() ) + { + connType = EConnectionCDMA; + } + else if( aConnectionTypeName == KConnectionCDMA20001xRTT() ) + { + connType = EConnectionCDMA20001xRTT; + } + else if( aConnectionTypeName == KConnectionCDMA20001xRTTDO() ) + { + connType = EConnectionCDMA20001xRTTDO ; + } + else if( aConnectionTypeName == KConnectionCDMA20001xRTTDV() ) + { + connType = EConnectionCDMA20001xRTTDV; + } + else if( aConnectionTypeName == KConnectionCDMA20003xRTT() ) + { + connType = EConnectionCDMA20003xRTT; + }*/ + else if( aConnectionTypeName == KConnectionEthernet() ) + { + connType = EConnectionEthernet; + } + else if( aConnectionTypeName == KConnectionWLAN() ) + { + connType = EConnectionWLAN; + } + else if( aConnectionTypeName == KConnectionBTPAN() ) + { + connType = EConnectionBTPAN; + } + return connType; + } + +RConnection::TConnStopType CT_DataCommsBase::ConnectionStopType( const TDesC& aConnectionStopType ) + { + RConnection::TConnStopType stopType = RConnection::EStopNormal; + if( aConnectionStopType == KStopAuthoritative() ) + { + stopType = RConnection::EStopAuthoritative; + } + return stopType; + } + +RConnection::TConnAttachType CT_DataCommsBase::ConnectionAttachType( const TDesC& aConnectionAttachType ) + { + RConnection::TConnAttachType connAttachType = RConnection::EAttachTypeNormal; + if( aConnectionAttachType == KAttachTypeMonitor() ) + { + connAttachType = RConnection::EAttachTypeMonitor; + } + return connAttachType; + } + +TUint CT_DataCommsBase::ProgressNotificationExpectedStage( const TDesC& aStage) + { + TUint expectedStage = 0; + if ( aStage == KStartingSelectionStr() ) + { + expectedStage = KStartingSelection; + } + else if ( aStage == KFinishedSelectionStr() ) + { + expectedStage = KFinishedSelection; + } + else if ( aStage == KConnectionOpenStr() ) + { + expectedStage = KConnectionOpen; + } + else if ( aStage == KLinkLayerOpenStr() ) + { + expectedStage = KLinkLayerOpen; + } + else if ( aStage == KLinkLayerClosedStr() ) + { + expectedStage = KLinkLayerClosed; + } + else if ( aStage == KNonExistentStr() ) + { + expectedStage = 1234; + } + return expectedStage; + } + +TBool CT_DataCommsBase::GetSockType( const TDesC& aSockTypeStr, TUint& aSockType ) + { + TBool found = ETrue; + + if( aSockTypeStr == KSockStreamStr() ) + { + aSockType = KSockStream; + } + else if( aSockTypeStr == KSockDatagramStr() ) + { + aSockType = KSockDatagram; + } + else + { + found = EFalse; + } + + return found; + } + +TBool CT_DataCommsBase::GetProtocol( const TDesC& aProtocolStr, TUint& aProtocol ) + { + TBool found = ETrue; + + if( aProtocolStr == KProtocolInetTcpStr() ) + { + aProtocol = KProtocolInetTcp; + } + else if( aProtocolStr == KProtocolInetUdpStr() ) + { + aProtocol = KProtocolInetUdp; + } + else + { + found = EFalse; + } + + return found; + } + +TBool CT_DataCommsBase::GetAddrFamily( const TDesC& aAddrFamilyStr, TUint& aAddrFamily ) + { + TBool found = ETrue; + + if( aAddrFamilyStr == KAFUnspecStr() ) + { + aAddrFamily = KAFUnspec; + } + else if( aAddrFamilyStr == KAfInetStr() ) + { + aAddrFamily = KAfInet; + } + else if( aAddrFamilyStr == KAfInet6Str() ) + { + aAddrFamily = KAfInet6; + } + else + { + found = EFalse; + } + + return found; + } + +TBool CT_DataCommsBase::GetCapability( const TDesC& aCapabilityStr, TCapability& aCapability ) + { + TBool found = ETrue; + + if( aCapabilityStr == ECapabilityTCBStr() ) + { + aCapability = ECapabilityTCB; + } + else if( aCapabilityStr == ECapabilityCommDDStr() ) + { + aCapability = ECapabilityCommDD; + } + else if( aCapabilityStr == ECapabilityPowerMgmtStr() ) + { + aCapability = ECapabilityPowerMgmt; + } + else if( aCapabilityStr == ECapabilityMultimediaDDStr() ) + { + aCapability = ECapabilityMultimediaDD; + } + else if( aCapabilityStr == ECapabilityReadDeviceDataStr() ) + { + aCapability = ECapabilityReadDeviceData; + } + else if( aCapabilityStr == ECapabilityWriteDeviceDataStr() ) + { + aCapability = ECapabilityWriteDeviceData; + } + else if( aCapabilityStr == ECapabilityDRMStr() ) + { + aCapability = ECapabilityDRM; + } + else if( aCapabilityStr == ECapabilityTrustedUIStr() ) + { + aCapability = ECapabilityTrustedUI; + } + else if( aCapabilityStr == ECapabilityProtServStr() ) + { + aCapability = ECapabilityProtServ; + } + else if( aCapabilityStr == ECapabilityDiskAdminStr() ) + { + aCapability = ECapabilityDiskAdmin; + } + else if( aCapabilityStr == ECapabilityNetworkControlStr() ) + { + aCapability = ECapabilityNetworkControl; + } + else if( aCapabilityStr == ECapabilityAllFilesStr() ) + { + aCapability = ECapabilityAllFiles; + } + else if( aCapabilityStr == ECapabilitySwEventStr() ) + { + aCapability = ECapabilitySwEvent; + } + else if( aCapabilityStr == ECapabilityNetworkServicesStr() ) + { + aCapability = ECapabilityNetworkServices; + } + else if( aCapabilityStr == ECapabilityLocalServicesStr() ) + { + aCapability = ECapabilityLocalServices; + } + else if( aCapabilityStr == ECapabilityReadUserDataStr() ) + { + aCapability = ECapabilityReadUserData; + } + else if( aCapabilityStr == ECapabilityWriteUserDataStr() ) + { + aCapability = ECapabilityWriteUserData; + } + else if( aCapabilityStr == ECapabilityLocationStr() ) + { + aCapability = ECapabilityLocation; + } + else if( aCapabilityStr == ECapabilitySurroundingsDDStr() ) + { + aCapability = ECapabilitySurroundingsDD; + } + else if( aCapabilityStr == ECapabilityUserEnvironmentStr() ) + { + aCapability = ECapabilityUserEnvironment; + } + else if( aCapabilityStr == ECapability_LimitStr() ) + { + aCapability = ECapability_Limit; + } + else if( aCapabilityStr == ECapability_HardLimitStr() ) + { + aCapability = ECapability_HardLimit; + } + else if( aCapabilityStr == ECapability_NoneStr() ) + { + aCapability = ECapability_None; + } + else if( aCapabilityStr == ECapability_DeniedStr() ) + { + aCapability = ECapability_Denied; + } + else + { + found = EFalse; + } + + return found; + } + +TBool CT_DataCommsBase::SubConnectionType( const TDesC& aSubConnTypeStr, RSubConnection::TSubConnType& aSubConnType) + { + TBool found = ETrue; + + if( aSubConnTypeStr == KCreateNew() ) + { + aSubConnType = RSubConnection::ECreateNew; + } + else if( aSubConnTypeStr == KAttachToDefault() ) + { + aSubConnType = RSubConnection::EAttachToDefault; + } + else + { + found = EFalse; + } + + return found; + } + +TBool CT_DataCommsBase::GetEventGroupUid(const TDesC& aEventGroupUidStr, TInt32& aEventGroupUid) + { + TBool found = ETrue; + + if (aEventGroupUidStr == KSubConnGenericEventsImplUidStr()) + { + aEventGroupUid = KSubConnGenericEventsImplUid; + } + else + { + found = EFalse; + } + + return found; + } + + +TBool CT_DataCommsBase::GetEventMaskBits(const TDesC& aConstantName, TUint32& aEventMask) + { + TBool ret = ETrue; + + if (aConstantName == KSubConGenericEventParamsGrantedStr()) + { + aEventMask=KSubConGenericEventParamsGranted; + } + else if (aConstantName == KSubConGenericEventDataClientJoinedStr()) + { + aEventMask=KSubConGenericEventDataClientJoined; + } + else if (aConstantName == KSubConGenericEventDataClientLeftStr()) + { + aEventMask=KSubConGenericEventDataClientLeft; + } + else if (aConstantName == KSubConGenericEventSubConDownStr()) + { + aEventMask=KSubConGenericEventSubConDown; + } + else if (aConstantName == KSubConGenericEventParamsChangedStr()) + { + aEventMask=KSubConGenericEventParamsChanged; + } + else if (aConstantName == KSubConGenericEventParamsRejectedStr()) + { + aEventMask=KSubConGenericEventParamsRejected; + } + else + { + TInt location=aConstantName.Match(_L("*|*")); + if( location!=KErrNotFound ) + { + //Converting Left part of the data + TPtrC tempStr=aConstantName.Left(location); + ret=GetEventMaskBits(tempStr, aEventMask); + + //Converting right data can be with another "|" + tempStr.Set(aConstantName.Mid(location+1)); + + TUint32 tmp; + if ( GetEventMaskBits(tempStr, tmp) ) + { + aEventMask |= tmp; + } + else + { + ret = EFalse; + } + } + else + { + TInt flagInt; + TLex lex(aConstantName); + if (lex.Val(flagInt)==KErrNone) + { + aEventMask=flagInt; + } + else + { + ret=EFalse; + ERR_PRINTF2(_L("Given flag (%S) is invalid"), &aConstantName); + SetBlockResult(EFail); + } + } + } + + return ret; + } + +TBool CT_DataCommsBase::ParameterSetType( const TDesC& aParameterSetTypeStr, CSubConParameterFamily::TParameterSetType& aParameterSetType ) + { + TBool found = ETrue; + + if( aParameterSetTypeStr == KAcceptable() ) + { + aParameterSetType = CSubConParameterFamily::EAcceptable; + } + else if( aParameterSetTypeStr == KRequested() ) + { + aParameterSetType = CSubConParameterFamily::ERequested; + } + else if( aParameterSetTypeStr == KGranted() ) + { + aParameterSetType = CSubConParameterFamily::EGranted; + } + else + { + found = EFalse; + } + + return found; + } + +TUint32 CT_DataCommsBase::GetLowPowerMode(const TDesC& aConstantName) + { + _LIT(KEActiveMode, "EActiveMode"); + _LIT(KEHoldMode, "EHoldMode"); + _LIT(KESniffMode, "ESniffMode"); + _LIT(KEParkMode, "EParkMode"); + _LIT(KEScatterMode, "EScatterMode"); + //_LIT(KEAnyLowPowerMode, "EAnyLowPowerMode"); + + TUint32 lowPowerMode = EAnyLowPowerMode; + + if (aConstantName == KEActiveMode) + { + lowPowerMode = EActiveMode; + } + else if (aConstantName == KEHoldMode) + { + lowPowerMode = EHoldMode; + } + else if (aConstantName == KESniffMode) + { + lowPowerMode = ESniffMode; + } + else if (aConstantName == KEParkMode) + { + lowPowerMode = EParkMode; + } + else if (aConstantName == KEScatterMode) + { + lowPowerMode = EScatterMode; + } + else + { + lowPowerMode = EAnyLowPowerMode; + } + + return lowPowerMode; + } + +TBool CT_DataCommsBase::GetTShutdown(const TDesC& aConstantName, RSocket::TShutdown& aShutdown) + { + _LIT(KNormal, "ENormal"); + _LIT(KStopInput, "EStopInput"); + _LIT(KStopOutput, "EStopOutput"); + _LIT(KImmediate, "EImmediate"); + + TBool ret=ETrue; + + if (aConstantName == KNormal) + { + // Complete when socket output/input stopped. + aShutdown=RSocket::ENormal; + } + else if (aConstantName == KStopInput) + { + // Stop socket input and complete when input is stopped. + aShutdown=RSocket::EStopInput; + } + else if (aConstantName == KStopOutput) + { + // Stop socket output and complete when output is stopped. + aShutdown=RSocket::EStopOutput; + } + else if (aConstantName == KImmediate) + { + // Stop socket input/output and complete (abortive close). + aShutdown=RSocket::EImmediate; + } + else + { + // If we did not find the value go for default + // Complete when socket output/input stopped. + ret = EFalse; + aShutdown=RSocket::ENormal; + } + + return ret; + } + +TInt CT_DataCommsBase::GetTBTPacketType(const TDesC& aConstantName) + { + _LIT(KEPacketsDM1, "EPacketsDM1"); + _LIT(KEPacketsDH1, "EPacketsDH1"); + _LIT(KEPacketsDM3, "EPacketsDM1"); + _LIT(KEPacketsDH3, "EPacketsDH1"); + _LIT(KEPacketsDM5, "EPacketsDM1"); + _LIT(KEPacketsDH5, "EPacketsDH1"); + _LIT(KEPacketsHV1, "EPacketsHV1"); + _LIT(KEPacketsHV2, "EPacketsHV2"); + _LIT(KEPacketsHV3, "EPacketsHV3"); + _LIT(KEAnyACLPacket, "EAnyACLPacket"); + _LIT(KEAnySCOPacket, "EAnySCOPacket"); + + TInt packetType = EAnyPacket; + + //Description + //Bluetooth SIG specified values for indicating packet types. + // + //DM1, DH1, DM3, DH3, DM5, DH5 are ACL packet types + //HV1, HV2, HV3 are SCO (synchronous link) packet types + // + // + + //EPacketsDM1 + if (aConstantName == KEPacketsDM1) + { + packetType = EPacketsDM1; + } + //DH1 ACL packet type + else if (aConstantName == KEPacketsDH1) + { + packetType = EPacketsDH1; + } + //EPacketsDM3 + else if (aConstantName == KEPacketsDM3) + { + packetType = EPacketsDM3; + } + //DH3 ACL packet type + else if (aConstantName == KEPacketsDH3) + { + packetType = EPacketsDH3; + } + //EPacketsDM5 + else if (aConstantName == KEPacketsDM5) + { + packetType = EPacketsDM5; + } + //DH5 ACL packet type + else if (aConstantName == KEPacketsDH5) + { + packetType = EPacketsDH5; + } + //HV1 SCO packet type + else if (aConstantName == KEPacketsHV1) + { + packetType = EPacketsHV1; + } + //HV2 SCO packet type + else if (aConstantName == KEPacketsHV2) + { + packetType = EPacketsHV2; + } + //HV3 SCO packet type + else if (aConstantName == KEPacketsHV3) + { + packetType = EPacketsHV3; + } + + //TBTPacketTypeCombinations + //Description + //Bitmask values to help request combinations of packets. + + //Any ACL packet + else if (aConstantName == KEAnyACLPacket) + { + packetType = EAnyACLPacket; + } + //Any SCO packet + else if (aConstantName == KEAnySCOPacket) + { + packetType = EAnySCOPacket; + } + //Any packet + else + { + packetType = EAnyPacket; + } + + return packetType; + } + + +TUint32 CT_DataCommsBase::GetLinkStateNotifierBits(const TDesC& aConstantName) + { + _LIT(KENotifyMaster, "ENotifyMaster"); + _LIT(KENotifySlave, "ENotifySlave"); + + _LIT(KENotifyActiveMode, "ENotifyActiveMode"); + _LIT(KENotifySniffMode, "ENotifySniffMode"); + _LIT(KENotifyParkMode, "ENotifyParkMode"); + _LIT(KENotifyHoldMode, "ENotifyHoldMode"); + + _LIT(KENotifyMaxSlots1, "ENotifyMaxSlots1"); + _LIT(KENotifyMaxSlots3, "ENotifyMaxSlots3"); + _LIT(KENotifyMaxSlots5, "ENotifyMaxSlots5"); + + _LIT(KENotifyPacketsDM1, "ENotifyPacketsDM1"); + _LIT(KENotifyPacketsDH1, "ENotifyPacketsDH1"); + _LIT(KENotifyPacketsDM3, "ENotifyPacketsDM3"); + _LIT(KENotifyPacketsDH3, "ENotifyPacketsDH3"); + _LIT(KENotifyPacketsDM5, "ENotifyPacketsDM5"); + _LIT(KENotifyPacketsDH5, "ENotifyPacketsDH5"); + + _LIT(KENotifyPacketsHV1, "ENotifyPacketsHV1"); + _LIT(KENotifyPacketsHV2, "ENotifyPacketsHV2"); + _LIT(KENotifyPacketsHV3, "ENotifyPacketsHV3"); + + _LIT(KENotifyAuthenticationComplete, "ENotifyAuthenticationComplete"); + _LIT(KENotifyEncryptionChangeOn, "ENotifyEncryptionChangeOn"); + _LIT(KENotifyEncryptionChangeOff, "ENotifyEncryptionChangeOff"); + + + _LIT(KENotifyPhysicalLinkUp, "ENotifyPhysicalLinkUp"); + _LIT(KENotifyPhysicalLinkDown, "ENotifyPhysicalLinkDown"); + _LIT(KENotifyPhysicalLinkError, "ENotifyPhysicalLinkError"); + + _LIT(KENotifySCOLinkUp, "ENotifySCOLinkUp"); + _LIT(KENotifySCOLinkDown, "ENotifySCOLinkDown"); + _LIT(KENotifySCOLinkError, "ENotifySCOLinkError"); + + TUint32 linkStateNotifierBits = 0; + + // This is from BTTypes.h + + // Bitmask values for notifying/requesting notification of the state of a physical link. + // + // These values have a two fold purpose: + // 1) They can be used along with TBTPhysicalLinkStateNotifierCombinations to specify + // a set of baseband change events for which notification is desired. + // 2) They can be used to notify the state of a physical link or a subset of that state. + // For example if only mode change events are being monitored, then at each mode change event + // only the bit reperesenting the new mode will be returned, however if the whole link state + // is required, then a combination of bit values indicating that state will be returned. + // + // THESE BIT VALUES MUST ONLY BE USED WHEN REQUESTING NOTIFICATION, OR WHEN PARSING THE + // RESULTS OF A NOTIFICATION. All other baseband state activities should use one of the + // appropriate Bluetooth SIG specified enums + // TBTBasebandRole, TBTLinkMode, TBTLinkModeCombinations, TBTPacketType, + // TBTPacketTypeCombinations + // + + //Master + if (aConstantName == KENotifyMaster) + { + linkStateNotifierBits = ENotifyMaster; + } + //Slave + else if (aConstantName == KENotifySlave) + { + linkStateNotifierBits = ENotifySlave; + } + + //Active Mode + else if (aConstantName == KENotifyActiveMode) + { + linkStateNotifierBits = ENotifyActiveMode; + } + //Sniff mode + else if (aConstantName == KENotifySniffMode) + { + linkStateNotifierBits = ENotifySniffMode; + } + //Park mode + else if (aConstantName == KENotifyParkMode) + { + linkStateNotifierBits = ENotifyParkMode; + } + //Hold mode + else if (aConstantName == KENotifyHoldMode) + { + linkStateNotifierBits = ENotifyHoldMode; + } + + //Max slots 1 + else if (aConstantName == KENotifyMaxSlots1) + { + linkStateNotifierBits = ENotifyMaxSlots1; + } + //Max slots 3 + else if (aConstantName == KENotifyMaxSlots3) + { + linkStateNotifierBits = ENotifyMaxSlots3; + } + //Max slots 5 + else if (aConstantName == KENotifyMaxSlots5) + { + linkStateNotifierBits = ENotifyMaxSlots5; + } + + + //Packets DM1 + else if (aConstantName == KENotifyPacketsDM1) + { + linkStateNotifierBits = ENotifyPacketsDM1; + } + //Packets DH1 + else if (aConstantName == KENotifyPacketsDH1) + { + linkStateNotifierBits = ENotifyPacketsDH1; + } + //Packets DM3 + else if (aConstantName == KENotifyPacketsDM3) + { + linkStateNotifierBits = ENotifyPacketsDM3; + } + //Packets DH3 + else if (aConstantName == KENotifyPacketsDH3) + { + linkStateNotifierBits = ENotifyPacketsDH3; + } + //Packets DM5 + else if (aConstantName == KENotifyPacketsDM5) + { + linkStateNotifierBits = ENotifyPacketsDM5; + } + //Packets DH5 + else if (aConstantName == KENotifyPacketsDH5) + { + linkStateNotifierBits = ENotifyPacketsDH5; + } + + //HV1 + else if (aConstantName == KENotifyPacketsHV1) + { + linkStateNotifierBits = ENotifyPacketsHV1; + } + //HV2 + else if (aConstantName == KENotifyPacketsHV2) + { + linkStateNotifierBits = ENotifyPacketsHV2; + } + //HV3 + else if (aConstantName == KENotifyPacketsHV3) + { + linkStateNotifierBits = ENotifyPacketsHV3; + } + + //Authentication Complete + else if (aConstantName == KENotifyAuthenticationComplete) + { + linkStateNotifierBits = ENotifyAuthenticationComplete; + } + //Encryption Change On + else if (aConstantName == KENotifyEncryptionChangeOn) + { + linkStateNotifierBits = ENotifyEncryptionChangeOn; + } + //Encryption Change Off + else if (aConstantName == KENotifyEncryptionChangeOff) + { + linkStateNotifierBits = ENotifyEncryptionChangeOff; + } + //Physical Link Up + else if (aConstantName == KENotifyPhysicalLinkUp) + { + linkStateNotifierBits = ENotifyPhysicalLinkUp; + } + //Physical Link Down + else if (aConstantName == KENotifyPhysicalLinkDown) + { + linkStateNotifierBits = ENotifyPhysicalLinkDown; + } + //Physical Link Error + else if (aConstantName == KENotifyPhysicalLinkError) + { + linkStateNotifierBits = ENotifyPhysicalLinkError; + } + + //SCO Link Up + else if (aConstantName == KENotifySCOLinkUp) + { + linkStateNotifierBits = ENotifySCOLinkUp; + } + //SCO Link Down + else if (aConstantName == KENotifySCOLinkDown) + { + linkStateNotifierBits = ENotifySCOLinkDown; + } + //SCO Link Error + else if (aConstantName == KENotifySCOLinkError) + { + linkStateNotifierBits = ENotifySCOLinkError; + } + else + { + linkStateNotifierBits = 0; + } + + return linkStateNotifierBits; + } + +// method splitted in blocks to save stack space +TBool CT_DataCommsBase::GetIntValue(const TDesC& aConstantName, TInt& aValue) + { + TBool ret= ETrue; + // ************************************************************************ + // bt_sock.h + // ************************************************************************ + _LIT(KBTAddrFamilyName, "KBTAddrFamily"); + _LIT(KBTLinkManagerName, "KBTLinkManager"); + _LIT(KL2CAPName, "KL2CAP"); + _LIT(KRFCOMMName, "KRFCOMM"); + _LIT(KSDPName, "KSDP"); + _LIT(KAVCTPName, "KAVCTP"); + _LIT(KTCIL2CAPName, "KTCIL2CAP"); + _LIT(KBTMajorName, "KBTMajor"); + _LIT(KBTMinorName, "KBTMinor"); + _LIT(KBTBuildName, "KBTBuild"); + _LIT(KSolInetIpName, "KSolInetIp"); + _LIT(KSolBtBlogName, "KSolBtBlog"); + _LIT(KSolBtHCIName, "KSolBtHCI"); + _LIT(KSolBtLMName, "KSolBtLM"); + _LIT(KSolBtL2CAPName, "KSolBtL2CAP"); + _LIT(KSolBtRFCOMMName, "KSolBtRFCOMM"); + _LIT(KSolBtAVCTPName, "KSolBtAVCTP"); + _LIT(KSolBtACLName, "KSolBtACL"); + _LIT(KSolBtAVDTPSignallingName, "KSolBtAVDTPSignalling"); + _LIT(KSolBtAVDTPMediaName, "KSolBtAVDTPMedia"); + _LIT(KSolBtAVDTPReportingName, "KSolBtAVDTPReporting"); + _LIT(KSolBtAVDTPRecoveryName, "KSolBtAVDTPRecovery"); + _LIT(KSolBtAVDTPInternalName, "KSolBtAVDTPInternal"); + _LIT(KSolBtLMProxyName, "KSolBtLMProxy"); + _LIT(KSolBtSAPBaseName, "KSolBtSAPBase"); + _LIT(KSCOListenQueSizeName, "KSCOListenQueSize"); + _LIT(KL2MinMTUName, "KL2MinMTU"); + _LIT(KMaxPSMName, "KMaxPSM"); + _LIT(KMinUserPSMName, "KMinUserPSM"); + _LIT(KMinPSMName, "KMinPSM"); + _LIT(KHostResInquiryName, "KHostResInquiry"); + _LIT(KHostResNameName, "KHostResName"); + _LIT(KHostResIgnoreCacheName, "KHostResIgnoreCache"); + _LIT(KHostResCacheName, "KHostResCache"); + _LIT(KL2CAPEchoRequestIoctlName, "KL2CAPEchoRequestIoctl"); + _LIT(KL2CAPIncomingMTUIoctlName, "KL2CAPIncomingMTUIoctl"); + _LIT(KL2CAPOutgoingMTUIoctlName, "KL2CAPOutgoingMTUIoctl"); + _LIT(KL2CAPUpdateChannelConfigIoctlName, "KL2CAPUpdateChannelConfigIoctl"); + _LIT(KDefaultBasebandConnectionTimeoutName, "KDefaultBasebandConnectionTimeout"); + _LIT(KLMAddSCOConnIoctlName, "KLMAddSCOConnIoctl"); + _LIT(KHCIRemoveSCOConnIoctlName, "KHCIRemoveSCOConnIoctl"); + _LIT(KHCIChangePacketTypeIoctlName, "KHCIChangePacketTypeIoctl"); + _LIT(KHCIAuthRequestIoctlName, "KHCIAuthRequestIoctl"); + _LIT(KHCIEncryptIoctlName, "KHCIAuthRequestIoctl"); + _LIT(KHCIChangeLinkKeyIoctlName, "KHCIChangeLinkKeyIoctl"); + _LIT(KHCIMasterLinkKeyIoctlName, "KHCIMasterLinkKeyIoctl"); + _LIT(KHCIHoldModeIoctlName, "KHCIHoldModeIoctl"); + _LIT(KHCISniffModeIoctlName, "KHCISniffModeIoctl"); + _LIT(KHCIExitSniffModeIoctlName, "KHCIExitSniffModeIoctl"); + _LIT(KHCIParkModeIoctlName, "KHCIParkModeIoctl"); + _LIT(KHCIExitParkModeIoctlName, "KHCIExitParkModeIoctl"); + _LIT(KHCIReadPageTimeoutIoctlName, "KHCIReadPageTimeoutIoctl"); + _LIT(KHCIWritePageTimeoutIoctlName, "KHCIWritePageTimeoutIoctl"); + _LIT(KHCIReadScanEnableIoctlName, "KHCIReadScanEnableIoctl"); + _LIT(KHCIWriteScanEnableIoctlName, "KHCIWriteScanEnableIoctl"); + _LIT(KHCIReadDeviceClassIoctlName, "KHCIReadDeviceClassIoctl"); + _LIT(KHCIWriteDeviceClassIoctlName, "KHCIWriteDeviceClassIoctl"); + _LIT(KHCIReadVoiceSettingIoctlName, "KHCIReadVoiceSettingIoctl"); + _LIT(KHCIWriteVoiceSettingIoctlName, "KHCIWriteVoiceSettingIoctl"); + _LIT(KHCIReadHoldModeActivityIoctlName, "KHCIReadHoldModeActivityIoctl"); + _LIT(KHCIWriteHoldModeActivityIoctlName, "KHCIWriteHoldModeActivityIoctl"); + _LIT(KHCILocalVersionIoctlName, "KHCILocalVersionIoctl"); + _LIT(KHCILocalFeaturesIoctlName, "KHCILocalFeaturesIoctl"); + _LIT(KHCICountryCodeIoctlName, "KHCICountryCodeIoctl"); + _LIT(KHCILocalAddressIoctlName, "KHCILocalAddressIoctl"); + _LIT(KHCIWriteDiscoverabilityIoctlName, "KHCIWriteDiscoverabilityIoctl"); + _LIT(KHCIReadDiscoverabilityIoctlName, "KHCIReadDiscoverabilityIoctl"); + _LIT(KHCIReadAuthenticationEnableIoctlName, "KHCIReadAuthenticationEnableIoctl"); + _LIT(KHCIWriteAuthenticationEnableIoctlName, "KHCIWriteAuthenticationEnableIoctl"); + _LIT(KL2CAPPassiveAutoBindName, "KL2CAPPassiveAutoBind"); + _LIT(KRFCOMMModemStatusCmdIoctlName, "KRFCOMMModemStatusCmdIoctl"); + _LIT(KRFCOMMRemoteLineStatusCmdIoctlName, "KRFCOMMRemoteLineStatusCmdIoctl"); + _LIT(KRFCOMMRemotePortNegCmdIoctlName, "KRFCOMMRemotePortNegCmdIoctl"); + _LIT(KRFCOMMRemotePortNegRequestIoctlName, "KRFCOMMRemotePortNegRequestIoctl"); + _LIT(KRFCOMMConfigChangeIndicationIoctlName, "KRFCOMMConfigChangeIndicationIoctl"); + _LIT(KRFCOMMLocalPortParameterName, "KRFCOMMLocalPortParameter"); + _LIT(KRFCOMMGetAvailableServerChannelName, "KRFCOMMGetAvailableServerChannel"); + _LIT(KRFCOMMMaximumSupportedMTUName, "KRFCOMMMaximumSupportedMTU"); + _LIT(KRFCOMMGetDebug1Name, "KRFCOMMGetDebug1"); + _LIT(KRFCOMMGetRemoteModemStatusName, "KRFCOMMGetRemoteModemStatus"); + _LIT(KRFCOMMGetTransmitCreditName, "KRFCOMMGetTransmitCredit"); + _LIT(KRFCOMMGetReceiveCreditName, "KRFCOMMGetReceiveCredit"); + _LIT(KRFCOMMGetReUsedCountName, "KRFCOMMGetReUsedCount"); + _LIT(KRFCOMMFlowTypeCBFCName, "KRFCOMMFlowTypeCBFC"); + _LIT(KRFCOMMLocalModemStatusName, "KRFCOMMLocalModemStatus"); + _LIT(KErrNoneName, "KErrNone"); + _LIT(KErrCancelName, "KErrCancel"); + _LIT(KErrBadHandleName, "KErrBadHandle"); + _LIT(KZero, "Zero"); + _LIT(KOne, "One"); + _LIT(ELMOutboundACLSizeName, "ELMOutboundACLSize"); + _LIT(ELMInboundACLSizeName, "ELMInboundACLSize"); + _LIT(KLMGetACLHandleName, "KLMGetACLHandle"); + _LIT(KLMGetACLLinkCountName, "KLMGetACLLinkCount"); + _LIT(KLMGetACLLinkArrayName, "KLMGetACLLinkArray"); + _LIT(KLMSetBasebandConnectionPolicyName, "KLMSetBasebandConnectionPolicy"); + _LIT(KLMGetBasebandHandleName, "KLMGetBasebandHandle"); + _LIT(EBBSubscribePhysicalLinkName, "EBBSubscribePhysicalLink"); + _LIT(EBBBeginRawName, "EBBBeginRaw"); + _LIT(EBBRequestRoleMasterName, "EBBRequestRoleMaster"); + _LIT(EBBRequestRoleSlaveName, "EBBRequestRoleSlave"); + _LIT(EBBCancelModeRequestName, "EBBCancelModeRequest"); + _LIT(EBBRequestSniffName, "EBBRequestSniff"); + _LIT(EBBRequestParkName, "EBBRequestPark"); + _LIT(EBBRequestPreventRoleChangeName, "EBBRequestPreventRoleChange"); + _LIT(EBBRequestAllowRoleChangeName, "EBBRequestAllowRoleChange"); + _LIT(EBBRequestChangeSupportedPacketTypesName, "EBBRequestChangeSupportedPacketTypes"); + _LIT(EBBEnumeratePhysicalLinksName, "EBBEnumeratePhysicalLinks"); + _LIT(EBBGetPhysicalLinkStateName, "EBBGetPhysicalLinkState"); + _LIT(EBBGetSniffIntervalName, "EBBGetSniffInterval"); + _LIT(EBBRequestLinkAuthenticationName, "EBBRequestLinkAuthentication"); + _LIT(EBBRequestPreventSniffName, "EBBRequestPreventSniff"); + _LIT(EBBRequestPreventHoldName, "EBBRequestPreventHold"); + _LIT(EBBRequestPreventParkName, "EBBRequestPreventPark"); + _LIT(EBBRequestPreventAllLowPowerModesName, "EBBRequestPreventAllLowPowerModes"); + _LIT(EBBRequestAllowSniffName, "EBBRequestAllowSniff"); + _LIT(EBBRequestAllowHoldName, "EBBRequestAllowHold"); + _LIT(EBBRequestAllowParkName, "EBBRequestAllowPark"); + _LIT(EBBRequestAllowAllLowPowerModesName, "EBBRequestAllowAllLowPowerModes"); + _LIT(KBTRegisterCodServiceName, "KBTRegisterCodService"); + _LIT(KBTSecurityDeviceOverrideName, "KBTSecurityDeviceOverride"); + _LIT(KESockDefaultMessageSlotsName, "KESockDefaultMessageSlots"); + _LIT(KUseEmbeddedUniqueIdName, "KUseEmbeddedUniqueId"); + _LIT(KConnProgressDefaultName, "KConnProgressDefault"); + _LIT(KMaxSockAddrSizeName, "KMaxSockAddrSize"); + _LIT(KAfInetName, "KAfInet"); + _LIT(KAfInet6Name, "KAfInet6"); + _LIT(KAFUnspecName, "KAFUnspec"); + _LIT(KSockStreamName, "KSockStream"); + _LIT(KSockDatagramName, "KSockDatagram"); + _LIT(KSockSeqPacketName, "KSockSeqPacket"); + _LIT(KSockRawName, "KSockRaw"); + _LIT(KSOLSocketName, "KSOLSocket"); + _LIT(KLevelUnspecifiedName, "KLevelUnspecified"); + _LIT(KSODebugName, "KSODebug"); + _LIT(KSORecvBufName, "KSORecvBuf"); + _LIT(KSOSendBufName, "KSOSendBuf"); + _LIT(KSoReuseAddrName, "KSoReuseAddr"); + _LIT(KSONonBlockingIOName, "KSONonBlockingIO"); + _LIT(KSOBlockingIOName, "KSOBlockingIO"); + _LIT(KSOSelectPollName, "KSOSelectPoll"); + _LIT(KSOReadBytesPendingName, "KSOReadBytesPending"); + _LIT(KSOUrgentDataOffsetName, "KSOUrgentDataOffset"); + _LIT(KSOSelectLastErrorName, "KSOSelectLastError"); + _LIT(KSOEnableTransferName, "KSOEnableTransfer"); + _LIT(KSODisableTransferName, "KSODisableTransfer"); + _LIT(KSocketBufSizeUndefinedName, "KSocketBufSizeUndefined"); + _LIT(KSocketDefaultBufferSizeName, "KSocketDefaultBufferSize"); + _LIT(KSocketInternalOptionBitName, "KSocketInternalOptionBit"); + _LIT(KIOctlSelectName, "KIOctlSelect"); + _LIT(KSockSelectReadName, "KSockSelectRead"); + _LIT(KSockSelectWriteName, "KSockSelectWrite"); + _LIT(KSockSelectExceptName, "KSockSelectExcept"); + _LIT(KSockSelectReadContinuationName, "KSockSelectReadContinuation"); + _LIT(KSockWriteUrgentName, "KSockWriteUrgent"); + _LIT(KSocketInternalWriteBitName, "KSocketInternalWriteBit"); + _LIT(KSockWriteSystemMaskName, "KSockWriteSystemMask"); + _LIT(KSockReadPeekName, "KSockReadPeek"); + _LIT(KSocketInternalReadBitName, "KSocketInternalReadBit"); + _LIT(KSockReadContinuationName, "KSockReadContinuation"); + _LIT(KSIConnectionLessName, "KSIConnectionLess"); + _LIT(KSIReliableName, "KSIReliable"); + _LIT(KSIInOrderName, "KSIInOrder"); + _LIT(KSIMessageBasedName, "KSIMessageBased"); + _LIT(KSIDatagramName, "KSIDatagram"); + _LIT(KSIStreamBasedName, "KSIStreamBased"); + _LIT(KSIPseudoStreamName, "KSIPseudoStream"); + _LIT(KSIUrgentDataName, "KSIUrgentData"); + _LIT(KSIConnectDataName, "KSIConnectData"); + _LIT(KSIDisconnectDataName, "KSIDisconnectData"); + _LIT(KSIBroadcastName, "KSIBroadcast"); + _LIT(KSIMultiPointName, "KSIMultiPoint"); + _LIT(KSIQOSName, "KSIQOS"); + _LIT(KSIWriteOnlyName, "KSIWriteOnly"); + _LIT(KSIReadOnlyName, "KSIReadOnly"); + _LIT(KSIGracefulCloseName, "KSIGracefulClose"); + _LIT(KSICanReconnectName, "KSICanReconnect"); + _LIT(KSIPeekDataName, "KSIPeekData"); + _LIT(KSIRequiresOwnerInfoName, "KSIRequiresOwnerInfo"); + _LIT(KNSNameResolutionName, "KNSNameResolution"); + _LIT(KNSHeirarchicalNamingName, "KNSHeirarchicalNaming"); + _LIT(KNSRemoteDiscoveryName, "KNSRemoteDiscovery"); + _LIT(KNSServiceResolutionName, "KNSServiceResolution"); + _LIT(KNSNameRegistrationName, "KNSNameRegistration"); + _LIT(KNSServiceRegistrationName, "KNSServiceRegistration"); + _LIT(KNSDynamicAddressingName, "KNSDynamicAddressing"); + _LIT(KNSInfoDatabaseName, "KNSInfoDatabase"); + _LIT(KNSRequiresConnectionStartupName, "KNSRequiresConnectionStartup"); + _LIT(KSocketNoSecurityName, "KSocketNoSecurity"); + _LIT(KSecureSocketsName, "KSecureSockets"); + _LIT(KSocketMessageSizeIsStreamName, "KSocketMessageSizeIsStream"); + _LIT(KSocketMessageSizeUndefinedName, "KSocketMessageSizeUndefined"); + _LIT(KSocketMessageSizeNoLimitName, "KSocketMessageSizeNoLimit"); + _LIT(KUndefinedSockTypeName, "KUndefinedSockType"); + _LIT(KUndefinedProtocolName, "KUndefinedProtocol"); + _LIT(KErrWouldBlockName, "KErrWouldBlock"); + _LIT(KErrConnectionTerminatedName, "KErrConnectionTerminated"); + _LIT(KErrCannotFindProtocolName, "KErrCannotFindProtocol"); + _LIT(KCOLConnectionName, "KCOLConnection"); + _LIT(KCOLProviderName, "KCOLProvider"); + _LIT(KConnInternalOptionBitName, "KConnInternalOptionBit"); + _LIT(KConnWriteUserDataBitName, "KConnWriteUserDataBit"); + _LIT(KConnReadUserDataBitName, "KConnReadUserDataBit"); + _LIT(KCoEnumerateConnectionClientsName, "KCoEnumerateConnectionClients"); + _LIT(KCoGetConnectionClientInfoName, "KCoGetConnectionClientInfo"); + _LIT(KCoGetConnectionSocketInfoName, "KCoGetConnectionSocketInfo"); + _LIT(KConnectionTypeDefaultName, "KConnectionTypeDefault"); + _LIT(KSubConnParamsInterfaceUidName, "KSubConnParamsInterfaceUid"); + _LIT(KSubConnEventInterfaceUidName, "KSubConnEventInterfaceUid"); + _LIT(KSubConnGenericParamsImplUidName, "KSubConnGenericParamsImplUid"); + _LIT(KSubConnGenericEventsImplUidName, "KSubConnGenericEventsImplUid"); + _LIT(KSubConGlobalFamilyName, "KSubConGlobalFamily"); + _LIT(KSubConQoSFamilyName, "KSubConQoSFamily"); + _LIT(KSubConAuthorisationFamilyName, "KSubConAuthorisationFamily"); + _LIT(KNotificationEventMaxSizeName, "KNotificationEventMaxSize"); + + // BT Address Family + if (aConstantName==KBTAddrFamilyName) + { + aValue=KBTAddrFamily; + } + else if (aConstantName==KBTLinkManagerName) + { + aValue=KBTLinkManager; + } + else if (aConstantName==KL2CAPName) + { + aValue=KL2CAP; + } + else if (aConstantName==KRFCOMMName) + { + aValue=KRFCOMM; + } + else if (aConstantName==KSDPName) + { + aValue=KSDP; + } + else if (aConstantName==KAVCTPName) + { + aValue=KAVCTP; + } + else if (aConstantName==KTCIL2CAPName) + { + aValue=KTCIL2CAP; + } + else if (aConstantName==KBTMajorName) + { + aValue=KBTMajor; + } + else if (aConstantName==KBTMinorName) + { + aValue=KBTMinor; + } + else if (aConstantName==KBTBuildName) + { + aValue=KBTBuild; + } + else if (aConstantName==KSolInetIpName) + { + aValue=KSolInetIp; + } + else if (aConstantName==KSolBtBlogName) + { + aValue=KSolBtBlog; + } + else if (aConstantName==KSolBtHCIName) + { + aValue=KSolBtHCI; + } + else if (aConstantName==KSolBtLMName) + { + aValue=KSolBtLM; + } + else if (aConstantName==KSolBtL2CAPName) + { + aValue=KSolBtL2CAP; + } + else if (aConstantName==KSolBtRFCOMMName) + { + aValue=KSolBtRFCOMM; + } + else if (aConstantName==KSolBtAVCTPName) + { + aValue=KSolBtAVCTP; + } + else if (aConstantName==KSolBtACLName) + { + aValue=KSolBtACL; + } + else if (aConstantName==KSolBtAVDTPSignallingName) + { + aValue=KSolBtAVDTPSignalling; + } + else if (aConstantName==KSolBtAVDTPMediaName) + { + aValue=KSolBtAVDTPMedia; + } + else if (aConstantName==KSolBtAVDTPReportingName) + { + aValue=KSolBtAVDTPReporting; + } + else if (aConstantName==KSolBtAVDTPRecoveryName) + { + aValue=KSolBtAVDTPRecovery; + } + else if (aConstantName==KSolBtAVDTPInternalName) + { + aValue=KSolBtAVDTPInternal; + } + else if (aConstantName==KSolBtLMProxyName) + { + aValue=KSolBtLMProxy; + } + else if (aConstantName==KSolBtSAPBaseName) + { + aValue=KSolBtSAPBase; + } + else if (aConstantName==KSCOListenQueSizeName) + { + aValue=KSCOListenQueSize; + } + else if (aConstantName==KL2MinMTUName) + { + aValue=KL2MinMTU; + } + else if (aConstantName==KMaxPSMName) + { + aValue=KMaxPSM; + } + else if (aConstantName==KMinUserPSMName) + { + aValue=KMinUserPSM; + } + else if (aConstantName==KMinPSMName) + { + aValue=KMinPSM; + } + else if (aConstantName==KHostResInquiryName) + { + aValue=KHostResInquiry; + } + else if (aConstantName==KHostResNameName) + { + aValue=KHostResName; + } + else if (aConstantName==KHostResIgnoreCacheName) + { + aValue=KHostResIgnoreCache; + } + else if (aConstantName==KHostResCacheName) + { + aValue=KHostResCache; + } + else if (aConstantName==KL2CAPEchoRequestIoctlName) + { + aValue=KL2CAPEchoRequestIoctl; + } + else if (aConstantName==KL2CAPIncomingMTUIoctlName) + { + aValue=KL2CAPIncomingMTUIoctl; + } + else if (aConstantName==KL2CAPOutgoingMTUIoctlName) + { + aValue=KL2CAPOutgoingMTUIoctl; + } + else if (aConstantName==KL2CAPUpdateChannelConfigIoctlName) + { + aValue=KL2CAPUpdateChannelConfigIoctl; + } + else if (aConstantName==KDefaultBasebandConnectionTimeoutName) + { + aValue=KDefaultBasebandConnectionTimeout; + } + else if (aConstantName==KLMAddSCOConnIoctlName) + { + aValue=KLMAddSCOConnIoctl; + } + else if (aConstantName==KHCIRemoveSCOConnIoctlName) + { + aValue=KHCIRemoveSCOConnIoctl; + } + else if (aConstantName==KHCIChangePacketTypeIoctlName) + { + aValue=KHCIChangePacketTypeIoctl; + } + else if (aConstantName==KHCIAuthRequestIoctlName) + { + aValue=KHCIAuthRequestIoctl; + } + else if (aConstantName==KHCIEncryptIoctlName) + { + aValue=KHCIEncryptIoctl; + } + else if (aConstantName==KHCIChangeLinkKeyIoctlName) + { + aValue=KHCIChangeLinkKeyIoctl; + } + else if (aConstantName==KHCIMasterLinkKeyIoctlName) + { + aValue=KHCIMasterLinkKeyIoctl; + } + else if (aConstantName==KHCIHoldModeIoctlName) + { + aValue=KHCIHoldModeIoctl; + } + else if (aConstantName==KHCISniffModeIoctlName) + { + aValue=KHCISniffModeIoctl; + } + else if (aConstantName==KHCIExitSniffModeIoctlName) + { + aValue=KHCIExitSniffModeIoctl; + } + else if (aConstantName==KHCIParkModeIoctlName) + { + aValue=KHCIParkModeIoctl; + } + else if (aConstantName==KHCIExitParkModeIoctlName) + { + aValue=KHCIExitParkModeIoctl; + } + else if (aConstantName==KHCIReadPageTimeoutIoctlName) + { + aValue=KHCIReadPageTimeoutIoctl; + } + else if (aConstantName==KHCIWritePageTimeoutIoctlName) + { + aValue=KHCIWritePageTimeoutIoctl; + } + else if (aConstantName==KHCIReadScanEnableIoctlName) + { + aValue=KHCIReadScanEnableIoctl; + } + else if (aConstantName==KHCIWriteScanEnableIoctlName) + { + aValue=KHCIWriteScanEnableIoctl; + } + else if (aConstantName==KHCIReadDeviceClassIoctlName) + { + aValue=KHCIReadDeviceClassIoctl; + } + else if (aConstantName==KHCIWriteDeviceClassIoctlName) + { + aValue=KHCIWriteDeviceClassIoctl; + } + else if (aConstantName==KHCIReadVoiceSettingIoctlName) + { + aValue=KHCIReadVoiceSettingIoctl; + } + else if (aConstantName==KHCIWriteVoiceSettingIoctlName) + { + aValue=KHCIWriteVoiceSettingIoctl; + } + else if (aConstantName==KHCIReadHoldModeActivityIoctlName) + { + aValue=KHCIReadHoldModeActivityIoctl; + } + else if (aConstantName==KHCIWriteHoldModeActivityIoctlName) + { + aValue=KHCIWriteHoldModeActivityIoctl; + } + else if (aConstantName==KHCILocalVersionIoctlName) + { + aValue=KHCILocalVersionIoctl; + } + else if (aConstantName==KHCILocalFeaturesIoctlName) + { + aValue=KHCILocalFeaturesIoctl; + } + else if (aConstantName==KHCICountryCodeIoctlName) + { + aValue=KHCICountryCodeIoctl; + } + else if (aConstantName==KHCILocalAddressIoctlName) + { + aValue=KHCILocalAddressIoctl; + } + else if (aConstantName==KHCIWriteDiscoverabilityIoctlName) + { + aValue=KHCIWriteDiscoverabilityIoctl; + } + else if (aConstantName==KHCIReadDiscoverabilityIoctlName) + { + aValue=KHCIReadDiscoverabilityIoctl; + } + else if (aConstantName==KHCIReadAuthenticationEnableIoctlName) + { + aValue=KHCIReadAuthenticationEnableIoctl; + } + else if (aConstantName==KHCIWriteAuthenticationEnableIoctlName) + { + aValue=KHCIWriteAuthenticationEnableIoctl; + } + else if (aConstantName==KL2CAPPassiveAutoBindName) + { + aValue=KL2CAPPassiveAutoBind; + } + else if (aConstantName==KRFCOMMModemStatusCmdIoctlName) + { + aValue=KRFCOMMModemStatusCmdIoctl; + } + else if (aConstantName==KRFCOMMRemoteLineStatusCmdIoctlName) + { + aValue=KRFCOMMRemoteLineStatusCmdIoctl; + } + else if (aConstantName==KRFCOMMRemotePortNegCmdIoctlName) + { + aValue=KRFCOMMRemotePortNegCmdIoctl; + } + else if (aConstantName==KRFCOMMRemotePortNegRequestIoctlName) + { + aValue=KRFCOMMRemotePortNegRequestIoctl; + } + else if (aConstantName==KRFCOMMConfigChangeIndicationIoctlName) + { + aValue=KRFCOMMConfigChangeIndicationIoctl; + } + else if (aConstantName==KRFCOMMLocalPortParameterName) + { + aValue=KRFCOMMLocalPortParameter; + } + else if (aConstantName==KRFCOMMGetAvailableServerChannelName) + { + aValue=KRFCOMMGetAvailableServerChannel; + } + else if (aConstantName==KRFCOMMMaximumSupportedMTUName) + { + aValue=KRFCOMMMaximumSupportedMTU; + } + else if (aConstantName==KRFCOMMGetDebug1Name) + { + aValue=KRFCOMMGetDebug1; + } + else if (aConstantName==KRFCOMMGetRemoteModemStatusName) + { + aValue=KRFCOMMGetRemoteModemStatus; + } + else if (aConstantName==KRFCOMMGetTransmitCreditName) + { + aValue=KRFCOMMGetTransmitCredit; + } + else if (aConstantName==KRFCOMMGetReceiveCreditName) + { + aValue=KRFCOMMGetReceiveCredit; + } + else if (aConstantName==KRFCOMMGetReUsedCountName) + { + aValue=KRFCOMMGetReUsedCount; + } + else if (aConstantName==KRFCOMMFlowTypeCBFCName) + { + aValue=KRFCOMMFlowTypeCBFC; + } + else if (aConstantName==KRFCOMMLocalModemStatusName) + { + aValue=KRFCOMMLocalModemStatus; + } + else if (aConstantName==KErrNoneName) + { + aValue=KErrNone; + } + else if (aConstantName==KErrCancelName) + { + aValue=KErrCancel; + } + else if (aConstantName==KErrBadHandleName) + { + aValue=KErrBadHandle; + } + else if (aConstantName==KZero) + { + aValue=0; + } + else if (aConstantName==KOne) + { + aValue=1; + } + else if (aConstantName==ELMOutboundACLSizeName) + { + aValue=ELMOutboundACLSize; + } + else if (aConstantName==ELMInboundACLSizeName) + { + aValue=ELMInboundACLSize; + } + else if (aConstantName==KLMGetACLHandleName) + { + aValue=KLMGetACLHandle; + } + else if (aConstantName==KLMGetACLLinkCountName) + { + aValue=KLMGetACLLinkCount; + } + else if (aConstantName==KLMGetACLLinkArrayName) + { + aValue=KLMGetACLLinkArray; + } + else if (aConstantName==KLMSetBasebandConnectionPolicyName) + { + aValue=KLMSetBasebandConnectionPolicy; + } + else if (aConstantName==KLMGetBasebandHandleName) + { + aValue=KLMGetBasebandHandle; + } + else if (aConstantName==EBBSubscribePhysicalLinkName) + { + aValue=EBBSubscribePhysicalLink; + } + else if (aConstantName==EBBBeginRawName) + { + aValue=EBBBeginRaw; + } + else if (aConstantName==EBBRequestRoleMasterName) + { + aValue=EBBRequestRoleMaster; + } + else if (aConstantName==EBBRequestRoleSlaveName) + { + aValue=EBBRequestRoleSlave; + } + else if (aConstantName==EBBCancelModeRequestName) + { + aValue=EBBCancelModeRequest; + } + else if (aConstantName==EBBRequestSniffName) + { + aValue=EBBRequestSniff; + } + else if (aConstantName==EBBRequestParkName) + { + aValue=EBBRequestPark; + } + else if (aConstantName==EBBRequestPreventRoleChangeName) + { + aValue=EBBRequestPreventRoleChange; + } + else if (aConstantName==EBBRequestAllowRoleChangeName) + { + aValue=EBBRequestAllowRoleChange; + } + else if (aConstantName==EBBRequestChangeSupportedPacketTypesName) + { + aValue=EBBRequestChangeSupportedPacketTypes; + } + else if (aConstantName==EBBEnumeratePhysicalLinksName) + { + aValue=EBBEnumeratePhysicalLinks; + } + else if (aConstantName==EBBGetPhysicalLinkStateName) + { + aValue=EBBGetPhysicalLinkState; + } + else if (aConstantName==EBBGetSniffIntervalName) + { + aValue=EBBGetSniffInterval; + } + else if (aConstantName==EBBRequestLinkAuthenticationName) + { + aValue=EBBRequestLinkAuthentication; + } + else if (aConstantName==EBBRequestPreventSniffName) + { + aValue=EBBRequestPreventSniff; + } + else if (aConstantName==EBBRequestPreventHoldName) + { + aValue=EBBRequestPreventHold; + } + else if (aConstantName==EBBRequestPreventParkName) + { + aValue=EBBRequestPreventPark; + } + else if (aConstantName==EBBRequestPreventAllLowPowerModesName) + { + aValue=EBBRequestPreventAllLowPowerModes; + } + else if (aConstantName==EBBRequestAllowSniffName) + { + aValue=EBBRequestAllowSniff; + } + else if (aConstantName==EBBRequestAllowHoldName) + { + aValue=EBBRequestAllowHold; + } + else if (aConstantName==EBBRequestAllowParkName) + { + aValue=EBBRequestAllowPark; + } + else if (aConstantName==EBBRequestAllowAllLowPowerModesName) + { + aValue=EBBRequestAllowAllLowPowerModes; + } + else if (aConstantName==KBTRegisterCodServiceName) + { + aValue=KBTRegisterCodService; + } + else if (aConstantName==KBTSecurityDeviceOverrideName) + { + aValue=KBTSecurityDeviceOverride; + } + else if (aConstantName==KESockDefaultMessageSlotsName) + { + aValue=KESockDefaultMessageSlots; + } + else if (aConstantName==KUseEmbeddedUniqueIdName) + { + aValue=KUseEmbeddedUniqueId; + } + else if (aConstantName==KConnProgressDefaultName) + { + aValue=KConnProgressDefault; + } + else if (aConstantName==KMaxSockAddrSizeName) + { + aValue=KMaxSockAddrSize; + } + else if (aConstantName==KAfInetName) + { + aValue=KAfInet; + } + else if (aConstantName==KAfInet6Name) + { + aValue=KAfInet6; + } + else if (aConstantName==KAFUnspecName) + { + aValue=KAFUnspec; + } + else if (aConstantName==KSockStreamName) + { + aValue=KSockStream; + } + else if (aConstantName==KSockDatagramName) + { + aValue=KSockDatagram; + } + else if (aConstantName==KSockSeqPacketName) + { + aValue=KSockSeqPacket; + } + else if (aConstantName==KSockRawName) + { + aValue=KSockRaw; + } + else if (aConstantName==KSOLSocketName) + { + aValue=KSOLSocket; + } + else if (aConstantName==KLevelUnspecifiedName) + { + aValue=KLevelUnspecified; + } + else if (aConstantName==KSODebugName) + { + aValue=KSODebug; + } + else if (aConstantName==KSORecvBufName) + { + aValue=KSORecvBuf; + } + else if (aConstantName==KSOSendBufName) + { + aValue=KSOSendBuf; + } + else if (aConstantName==KSoReuseAddrName) + { + aValue=KSoReuseAddr; + } + else if (aConstantName==KSONonBlockingIOName) + { + aValue=KSONonBlockingIO; + } + else if (aConstantName==KSOBlockingIOName) + { + aValue=KSOBlockingIO; + } + else if (aConstantName==KSOSelectPollName) + { + aValue=KSOSelectPoll; + } + else if (aConstantName==KSOReadBytesPendingName) + { + aValue=KSOReadBytesPending; + } + else if (aConstantName==KSOUrgentDataOffsetName) + { + aValue=KSOUrgentDataOffset; + } + else if (aConstantName==KSOSelectLastErrorName) + { + aValue=KSOSelectLastError; + } + else if (aConstantName==KSOEnableTransferName) + { + aValue=KSOEnableTransfer; + } + else if (aConstantName==KSODisableTransferName) + { + aValue=KSODisableTransfer; + } + else if (aConstantName==KSocketBufSizeUndefinedName) + { + aValue=KSocketBufSizeUndefined; + } + else if (aConstantName==KSocketDefaultBufferSizeName) + { + aValue=KSocketDefaultBufferSize; + } + else if (aConstantName==KSocketInternalOptionBitName) + { + aValue=KSocketInternalOptionBit; + } + else if (aConstantName==KIOctlSelectName) + { + aValue=KIOctlSelect; + } + else if (aConstantName==KSockSelectReadName) + { + aValue=KSockSelectRead; + } + else if (aConstantName==KSockSelectWriteName) + { + aValue=KSockSelectWrite; + } + else if (aConstantName==KSockSelectExceptName) + { + aValue=KSockSelectExcept; + } + else if (aConstantName==KSockSelectReadContinuationName) + { + aValue=KSockSelectReadContinuation; + } + else if (aConstantName==KSockWriteUrgentName) + { + aValue=KSockWriteUrgent; + } + else if (aConstantName==KSocketInternalWriteBitName) + { + aValue=KSocketInternalWriteBit; + } + else if (aConstantName==KSockWriteSystemMaskName) + { + aValue=KSockWriteSystemMask; + } + else if (aConstantName==KSockReadPeekName) + { + aValue=KSockReadPeek; + } + else if (aConstantName==KSocketInternalReadBitName) + { + aValue=KSocketInternalReadBit; + } + else if (aConstantName==KSockReadContinuationName) + { + aValue=KSockReadContinuation; + } + else if (aConstantName==KSIConnectionLessName) + { + aValue=KSIConnectionLess; + } + else if (aConstantName==KSIReliableName) + { + aValue=KSIReliable; + } + else if (aConstantName==KSIInOrderName) + { + aValue=KSIInOrder; + } + else if (aConstantName==KSIMessageBasedName) + { + aValue=KSIMessageBased; + } + else if (aConstantName==KSIDatagramName) + { + aValue=KSIDatagram; + } + else if (aConstantName==KSIStreamBasedName) + { + aValue=KSIStreamBased; + } + else if (aConstantName==KSIPseudoStreamName) + { + aValue=KSIPseudoStream; + } + else if (aConstantName==KSIUrgentDataName) + { + aValue=KSIUrgentData; + } + else if (aConstantName==KSIConnectDataName) + { + aValue=KSIConnectData; + } + else if (aConstantName==KSIDisconnectDataName) + { + aValue=KSIDisconnectData; + } + else if (aConstantName==KSIBroadcastName) + { + aValue=KSIBroadcast; + } + else if (aConstantName==KSIMultiPointName) + { + aValue=KSIMultiPoint; + } + else if (aConstantName==KSIQOSName) + { + aValue=KSIQOS; + } + else if (aConstantName==KSIWriteOnlyName) + { + aValue=KSIWriteOnly; + } + else if (aConstantName==KSIReadOnlyName) + { + aValue=KSIReadOnly; + } + else if (aConstantName==KSIGracefulCloseName) + { + aValue=KSIGracefulClose; + } + else if (aConstantName==KSICanReconnectName) + { + aValue=KSICanReconnect; + } + else if (aConstantName==KSIPeekDataName) + { + aValue=KSIPeekData; + } + else if (aConstantName==KSIRequiresOwnerInfoName) + { + aValue=KSIRequiresOwnerInfo; + } + else if (aConstantName==KNSNameResolutionName) + { + aValue=KNSNameResolution; + } + else if (aConstantName==KNSHeirarchicalNamingName) + { + aValue=KNSHeirarchicalNaming; + } + else if (aConstantName==KNSRemoteDiscoveryName) + { + aValue=KNSRemoteDiscovery; + } + else if (aConstantName==KNSServiceResolutionName) + { + aValue=KNSServiceResolution; + } + else if (aConstantName==KNSNameRegistrationName) + { + aValue=KNSNameRegistration; + } + else if (aConstantName==KNSServiceRegistrationName) + { + aValue=KNSServiceRegistration; + } + else if (aConstantName==KNSDynamicAddressingName) + { + aValue=KNSDynamicAddressing; + } + else if (aConstantName==KNSInfoDatabaseName) + { + aValue=KNSInfoDatabase; + } + else if (aConstantName==KNSRequiresConnectionStartupName) + { + aValue=KNSRequiresConnectionStartup; + } + else if (aConstantName==KSocketNoSecurityName) + { + aValue=KSocketNoSecurity; + } + else if (aConstantName==KSecureSocketsName) + { + aValue=KSecureSockets; + } + else if (aConstantName==KSocketMessageSizeIsStreamName) + { + aValue=KSocketMessageSizeIsStream; + } + else if (aConstantName==KSocketMessageSizeUndefinedName) + { + aValue=KSocketMessageSizeUndefined; + } + else if (aConstantName==KSocketMessageSizeNoLimitName) + { + aValue=KSocketMessageSizeNoLimit; + } + else if (aConstantName==KUndefinedSockTypeName) + { + aValue=KUndefinedSockType; + } + else if (aConstantName==KUndefinedProtocolName) + { + aValue=KUndefinedProtocol; + } + else if (aConstantName==KErrWouldBlockName) + { + aValue=KErrWouldBlock; + } + else if (aConstantName==KErrConnectionTerminatedName) + { + aValue=KErrConnectionTerminated; + } + else if (aConstantName==KErrCannotFindProtocolName) + { + aValue=KErrCannotFindProtocol; + } + else if (aConstantName==KCOLConnectionName) + { + aValue=KCOLConnection; + } + else if (aConstantName==KCOLProviderName) + { + aValue=KCOLProvider; + } + else if (aConstantName==KConnInternalOptionBitName) + { + aValue=KConnInternalOptionBit; + } + else if (aConstantName==KConnWriteUserDataBitName) + { + aValue=KConnWriteUserDataBit; + } + else if (aConstantName==KConnReadUserDataBitName) + { + aValue=KConnReadUserDataBit; + } + else if (aConstantName==KCoEnumerateConnectionClientsName) + { + aValue=KCoEnumerateConnectionClients; + } + else if (aConstantName==KCoGetConnectionClientInfoName) + { + aValue=KCoGetConnectionClientInfo; + } + else if (aConstantName==KCoGetConnectionSocketInfoName) + { + aValue=KCoGetConnectionSocketInfo; + } + else if (aConstantName==KConnectionTypeDefaultName) + { + aValue=KConnectionTypeDefault; + } + else if (aConstantName==KSubConnParamsInterfaceUidName) + { + aValue=KSubConnParamsInterfaceUid; + } + else if (aConstantName==KSubConnEventInterfaceUidName) + { + aValue=KSubConnEventInterfaceUid; + } + else if (aConstantName==KSubConnGenericParamsImplUidName) + { + aValue=KSubConnGenericParamsImplUid; + } + else if (aConstantName==KSubConnGenericEventsImplUidName) + { + aValue=KSubConnGenericEventsImplUid; + } + else if (aConstantName==KSubConGlobalFamilyName) + { + aValue=KSubConGlobalFamily; + } + else if (aConstantName==KSubConQoSFamilyName) + { + aValue=KSubConQoSFamily; + } + else if (aConstantName==KSubConAuthorisationFamilyName) + { + aValue=KSubConAuthorisationFamily; + } + else if (aConstantName==KNotificationEventMaxSizeName) + { + aValue=KNotificationEventMaxSize; + } + else + { + ret=EFalse; + aValue=-1; + } + + return ret; + } + +void CT_DataCommsBase::ConvertWhiteSpace(const TDesC & inputData, TDes & convertedData) + { + for (int pos = 0; pos < inputData.Length(); ++pos) + { + if (inputData[pos] == '\r') + { + convertedData.Append(_L("\\r")); + } + else if (inputData[pos] == '\n') + { + convertedData.Append(_L("\\n")); + } + else + { + convertedData.Append(inputData[pos]); + } + } + } + +void CT_DataCommsBase::PrintProtocol(const TDesC& aDesc, const TProtocolDesc& aProtocol, TBool aShowServiceInfoFlags /* = EFalse */ ) + { + TBuf versionName(aProtocol.iVersion.Name()); + INFO_PRINTF3(_L("%S.iAddrFamily = %d"), &aDesc, aProtocol.iAddrFamily); + INFO_PRINTF3(_L("%S.iByteOrder = %d"), &aDesc, aProtocol.iByteOrder); + INFO_PRINTF3(_L("%S.iMessageSize = %d"), &aDesc, aProtocol.iMessageSize); + INFO_PRINTF3(_L("%S.iName = %S"), &aDesc, &aProtocol.iName); + INFO_PRINTF3(_L("%S.iNamingServices = %d"), &aDesc, aProtocol.iNamingServices); + INFO_PRINTF3(_L("%S.iProtocol = %d"), &aDesc, aProtocol.iProtocol); + INFO_PRINTF3(_L("%S.iSecurity = %d"), &aDesc, aProtocol.iSecurity); + INFO_PRINTF3(_L("%S.iServiceInfo = %d"), &aDesc, aProtocol.iServiceInfo); + + if( aShowServiceInfoFlags ) + { + INFO_PRINTF3(_L("%S KSIConnectionLess = %d"), &aDesc, (aProtocol.iServiceInfo & KSIConnectionLess) ? 1 : 0); + INFO_PRINTF3(_L("%S KSIConnectData = %d"), &aDesc, (aProtocol.iServiceInfo & KSIConnectData) ? 1 : 0); + INFO_PRINTF3(_L("%S KSIDisconnectData = %d"), &aDesc, (aProtocol.iServiceInfo & KSIDisconnectData) ? 1 : 0); + INFO_PRINTF3(_L("%S KSIUrgentData = %d"), &aDesc, (aProtocol.iServiceInfo & KSIUrgentData) ? 1 : 0); + INFO_PRINTF3(_L("%S KSIPeekData = %d"), &aDesc, (aProtocol.iServiceInfo & KSIPeekData) ? 1 : 0); + INFO_PRINTF3(_L("%S KSIGracefulClose = %d"), &aDesc, (aProtocol.iServiceInfo & KSIGracefulClose) ? 1 : 0); + } + + INFO_PRINTF3(_L("%S.iSockType = %d"), &aDesc, aProtocol.iSockType); + INFO_PRINTF3(_L("%S.iVersion = %S"), &aDesc, &versionName); + INFO_PRINTF1(_L("------------------------------------------------------------")); + } + +TBool CT_DataCommsBase::CompareProtocolInfo(TProtocolDesc& aLhs, TProtocolDesc& aRhs) + { + TBool returnVal = ETrue; + if (aLhs.iAddrFamily != aRhs.iAddrFamily || + aLhs.iByteOrder != aRhs.iByteOrder || + aLhs.iMessageSize != aRhs.iMessageSize || + aLhs.iName != aRhs.iName || + aLhs.iNamingServices != aRhs.iNamingServices || + aLhs.iProtocol != aRhs.iProtocol || + aLhs.iSecurity != aRhs.iSecurity || + aLhs.iServiceInfo != aRhs.iServiceInfo || + aLhs.iSockType != aRhs.iSockType || + aLhs.iVersion.Name() != aRhs.iVersion.Name()) + { + returnVal = EFalse; + } + + return returnVal; + } + +TInt CT_DataCommsBase::GetStringAsInt( const TDesC& aSection, const TDesC& aStrParameter ) + { + + TPtrC valueStr(_L("")); + TInt valueInt; + // First look for an integer value + if (!GetIntFromConfig(aSection, aStrParameter, valueInt)) + { + // Didn't find an integer value - look for a string + TBool hasStringVal = GetStringFromConfig(aSection, aStrParameter, valueStr); + if (hasStringVal) + { + // Found a string error - convert into an integer + if ( !GetIntValue(valueStr, valueInt) ) + { + ERR_PRINTF2(_L("%S constant was not found"), &valueStr); + SetBlockResult(EFail); + } + } + else + { + valueInt = KErrNone; + } + } + + return valueInt; + }