1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "T_DataCommsBase.h"

    19 

    20 //	Epoc includes

    21 #include <in_sock.h>

    22 #include <es_sock.h>

    23 #include <es_enum.h>

    24 #include <bt_sock.h>

    25 #include <cs_subconevents.h>

    26 

    27 /*@{*/

    28 ///	Constant Literals used.

    29 _LIT(KInterfaceDownBuf,							"EInterfaceDown");

    30 

    31 // TConnectionType

    32 _LIT(KConnectionCSD ,							"EConnectionCSD ");

    33 _LIT(KConnectionGPRS,							"EConnectionGPRS");

    34 _LIT(KConnectionGPRSR97,						"EConnectionGPRSR97");

    35 _LIT(KConnectionGPRSR99,						"EConnectionGPRSR99");

    36 _LIT(KConnectionGPRSRel4,						"EConnectionGPRSRel4");

    37 _LIT(KConnectionGPRSRel5,						"EConnectionGPRSRel5");

    38 //_LIT(KConnectionCDMA,							"EConnectionCDMA");

    39 //_LIT(KConnectionCDMA20001xRTT,					"EConnectionCDMA20001xRTT");

    40 //_LIT(KConnectionCDMA20001xRTTDO,				"EConnectionCDMA20001xRTTDO ");

    41 //_LIT(KConnectionCDMA20001xRTTDV,				"EConnectionCDMA20001xRTTDV");

    42 //_LIT(KConnectionCDMA20003xRTT,					"EConnectionCDMA20003xRTT");

    43 _LIT(KConnectionEthernet,						"EConnectionEthernet");

    44 _LIT(KConnectionWLAN,							"EConnectionWLAN");

    45 _LIT(KConnectionBTPAN,							"EConnectionBTPAN");

    46 

    47 // TConnStopType

    48 _LIT(KStopAuthoritative,						"EStopAuthoritative");

    49 

    50 // TConnAttachType

    51 _LIT(KAttachTypeMonitor,						"EAttachTypeMonitor");

    52 

    53 // SockType

    54 _LIT(KSockStreamStr,							"KSockStream");

    55 _LIT(KSockDatagramStr,							"KSockDatagram");

    56 

    57 // Protocol

    58 _LIT(KProtocolInetTcpStr,						"KProtocolInetTcp");

    59 _LIT(KProtocolInetUdpStr,						"KProtocolInetUdp");

    60 

    61 // AddrFamily

    62 _LIT(KAFUnspecStr,								"KAFUnspec");

    63 _LIT(KAfInetStr,								"KAfInet");

    64 _LIT(KAfInet6Str,								"KAfInet6");

    65 

    66 // Capability

    67 _LIT(ECapabilityTCBStr,							"ECapabilityTCB");

    68 _LIT(ECapabilityCommDDStr,						"ECapabilityCommDD");

    69 _LIT(ECapabilityPowerMgmtStr,					"ECapabilityPowerMgmt");

    70 _LIT(ECapabilityMultimediaDDStr,				"ECapabilityMultimediaDD");

    71 _LIT(ECapabilityReadDeviceDataStr,				"ECapabilityReadDeviceData");

    72 _LIT(ECapabilityWriteDeviceDataStr,				"ECapabilityWriteDeviceData");

    73 _LIT(ECapabilityDRMStr,							"ECapabilityDRM");

    74 _LIT(ECapabilityTrustedUIStr,					"ECapabilityTrustedUI");

    75 _LIT(ECapabilityProtServStr,					"ECapabilityProtServ");

    76 _LIT(ECapabilityDiskAdminStr,					"ECapabilityDiskAdmin");

    77 _LIT(ECapabilityNetworkControlStr,				"ECapabilityNetworkControl");

    78 _LIT(ECapabilityAllFilesStr,					"ECapabilityAllFiles");

    79 _LIT(ECapabilitySwEventStr,						"ECapabilitySwEvent");

    80 _LIT(ECapabilityNetworkServicesStr,				"ECapabilityNetworkServices");

    81 _LIT(ECapabilityLocalServicesStr,				"ECapabilityLocalServices");

    82 _LIT(ECapabilityReadUserDataStr,				"ECapabilityReadUserData");

    83 _LIT(ECapabilityWriteUserDataStr,				"ECapabilityWriteUserData");

    84 _LIT(ECapabilityLocationStr,					"ECapabilityLocation");

    85 _LIT(ECapabilitySurroundingsDDStr,				"ECapabilitySurroundingsDD");

    86 _LIT(ECapabilityUserEnvironmentStr,				"ECapabilityUserEnvironment");

    87 _LIT(ECapability_LimitStr,						"ECapability_Limit");

    88 _LIT(ECapability_HardLimitStr,					"ECapability_HardLimit");

    89 _LIT(ECapability_NoneStr,						"ECapability_None");

    90 _LIT(ECapability_DeniedStr,						"ECapability_Denied");

    91 

    92 // ProgressNotification stages

    93 _LIT(KStartingSelectionStr,						"KStartingSelection");

    94 _LIT(KFinishedSelectionStr,						"KFinishedSelection");

    95 _LIT(KConnectionOpenStr,						"KConnectionOpen");

    96 _LIT(KLinkLayerOpenStr,							"KLinkLayerOpen");

    97 _LIT(KLinkLayerClosedStr,						"KLinkLayerClosed");

    98 _LIT(KNonExistentStr,							"KNonExistent");

    99 

   100 // TSubConnType

   101 _LIT(KCreateNew,								"ECreateNew");

   102 _LIT(KAttachToDefault,							"EAttachToDefault");

   103 

   104 // EventGroupUid

   105 _LIT(KSubConnGenericEventsImplUidStr,			"KSubConnGenericEventsImplUid");

   106 

   107 // EventNotification events

   108 _LIT(KSubConGenericEventParamsGrantedStr,		"KSubConGenericEventParamsGranted");

   109 _LIT(KSubConGenericEventDataClientJoinedStr,	"KSubConGenericEventDataClientJoined");

   110 _LIT(KSubConGenericEventDataClientLeftStr,		"KSubConGenericEventDataClientLeft");

   111 _LIT(KSubConGenericEventSubConDownStr,			"KSubConGenericEventSubConDown");

   112 _LIT(KSubConGenericEventParamsChangedStr,		"KSubConGenericEventParamsChanged");

   113 _LIT(KSubConGenericEventParamsRejectedStr,		"KSubConGenericEventParamsRejected");

   114 

   115 // ParameterSetType

   116 

   117 _LIT(KAcceptable,								"EAcceptable");

   118 _LIT(KRequested,								"ERequested");

   119 _LIT(KGranted,									"EGranted");

   120 /*@}*/

   121 

   122 

   123 CT_DataCommsBase::CT_DataCommsBase()

   124 	{

   125 	}

   126 

   127 CT_DataCommsBase::~CT_DataCommsBase()

   128 	{

   129 	}

   130 

   131 void CT_DataCommsBase::RunL( CActive* aActive, TInt /*aIndex*/ )

   132 	{

   133 	ERR_PRINTF2(_L("RunL Stray signal, status = %d"), aActive->iStatus.Int());

   134 	SetBlockResult(EFail);

   135 	}

   136 

   137 void CT_DataCommsBase::DoCancel( CActive* aActive, TInt /*aIndex*/ )

   138 	{

   139 	ERR_PRINTF2(_L("DoCancel Stray signal, status = %d"), aActive->iStatus.Int());

   140 	SetBlockResult(EFail);

   141 	}

   142 

   143 void CT_DataCommsBase::MissingParamError( const TDesC& aParamName )

   144 	{

   145 	ERR_PRINTF2(_L("No %S"), &aParamName);

   146 	SetBlockResult(EFail);

   147 	}

   148 

   149 TConnInterfaceState	CT_DataCommsBase::InterfaceNotificationState( const TDesC& aState )

   150 	{

   151 	TConnInterfaceState state = EInterfaceUp;

   152 	if( aState == KInterfaceDownBuf() )

   153 		{

   154 		state = EInterfaceDown;

   155 		}

   156 	return state;

   157 	}

   158 

   159 TConnectionType CT_DataCommsBase::ConnectionType( const TDesC& aConnectionTypeName )

   160 	{

   161 	TConnectionType	connType = EConnectionGeneric;

   162 	if( aConnectionTypeName == KConnectionCSD() )

   163 		{

   164 		connType = EConnectionCSD;

   165 		}

   166 	else if( aConnectionTypeName == KConnectionGPRS() )

   167 		{

   168 		connType = EConnectionGPRS;

   169 		}

   170 	else if( aConnectionTypeName == KConnectionGPRSR97() )

   171 		{

   172 		connType = EConnectionGPRSR97;

   173 		}

   174 	else if( aConnectionTypeName == KConnectionGPRSR99() )

   175 		{

   176 		connType = EConnectionGPRSR99;

   177 		}

   178 	else if( aConnectionTypeName == KConnectionGPRSRel4() )

   179 		{

   180 		connType = EConnectionGPRSRel4;

   181 		}

   182 	else if( aConnectionTypeName == KConnectionGPRSRel5() )

   183 		{

   184 		connType = EConnectionGPRSRel5;

   185 		}

   186 /*	else if( aConnectionTypeName == KConnectionCDMA() )

   187 		{

   188 		connType = EConnectionCDMA;

   189 		}

   190 	else if( aConnectionTypeName == KConnectionCDMA20001xRTT() )

   191 		{

   192 		connType = EConnectionCDMA20001xRTT;

   193 		}

   194 	else if( aConnectionTypeName == KConnectionCDMA20001xRTTDO() )

   195 		{

   196 		connType = EConnectionCDMA20001xRTTDO ;

   197 		}

   198 	else if( aConnectionTypeName == KConnectionCDMA20001xRTTDV() )

   199 		{

   200 		connType = EConnectionCDMA20001xRTTDV;

   201 		}

   202 	else if( aConnectionTypeName == KConnectionCDMA20003xRTT() )

   203 		{

   204 		connType = EConnectionCDMA20003xRTT;

   205 		}*/

   206 	else if( aConnectionTypeName == KConnectionEthernet() )

   207 		{

   208 		connType = EConnectionEthernet;

   209 		}

   210 	else if( aConnectionTypeName == KConnectionWLAN() )

   211 		{

   212 		connType = EConnectionWLAN;

   213 		}

   214 	else if( aConnectionTypeName == KConnectionBTPAN() )

   215 		{

   216 		connType = EConnectionBTPAN;

   217 		}

   218 	return connType;

   219 	}

   220 

   221 RConnection::TConnStopType CT_DataCommsBase::ConnectionStopType( const TDesC& aConnectionStopType )

   222 	{

   223 	RConnection::TConnStopType	stopType = RConnection::EStopNormal;

   224 	if( aConnectionStopType == KStopAuthoritative() )

   225 		{

   226 		stopType = RConnection::EStopAuthoritative;

   227 		}

   228 	return stopType;

   229 	}

   230 

   231 RConnection::TConnAttachType CT_DataCommsBase::ConnectionAttachType( const TDesC& aConnectionAttachType )

   232 	{

   233 	RConnection::TConnAttachType	connAttachType = RConnection::EAttachTypeNormal;

   234 	if( aConnectionAttachType == KAttachTypeMonitor() )

   235 		{

   236 		connAttachType = RConnection::EAttachTypeMonitor;

   237 		}

   238 	return connAttachType;

   239 	}

   240 

   241 TUint CT_DataCommsBase::ProgressNotificationExpectedStage( const TDesC& aStage)

   242 	{

   243 	TUint expectedStage = 0;

   244 	if ( aStage == KStartingSelectionStr() )

   245 		{

   246 		expectedStage = KStartingSelection;

   247 		}

   248 	else if ( aStage == KFinishedSelectionStr() )

   249 		{

   250 		expectedStage = KFinishedSelection;

   251 		}

   252 	else if ( aStage == KConnectionOpenStr() )

   253 		{

   254 		expectedStage = KConnectionOpen;

   255 		}

   256 	else if ( aStage == KLinkLayerOpenStr() )

   257 		{

   258 		expectedStage = KLinkLayerOpen;

   259 		}

   260 	else if ( aStage == KLinkLayerClosedStr() )

   261 		{

   262 		expectedStage = KLinkLayerClosed;

   263 		}

   264 	else if ( aStage == KNonExistentStr() )

   265 		{

   266 		expectedStage = 1234;

   267 		}

   268 	return expectedStage;

   269 	}

   270 

   271 TBool CT_DataCommsBase::GetSockType( const TDesC& aSockTypeStr, TUint& aSockType )

   272 	{

   273 	TBool found = ETrue;

   274 

   275 	if( aSockTypeStr == KSockStreamStr() )

   276 		{

   277 		aSockType = KSockStream;

   278 		}

   279 	else if( aSockTypeStr == KSockDatagramStr() )

   280 		{

   281 		aSockType = KSockDatagram;

   282 		}

   283 	else

   284 		{

   285 		found = EFalse;

   286 		}

   287 

   288 	return found;

   289 	}

   290 

   291 TBool CT_DataCommsBase::GetProtocol( const TDesC& aProtocolStr, TUint& aProtocol )

   292 	{

   293 	TBool found = ETrue;

   294 

   295 	if( aProtocolStr == KProtocolInetTcpStr() )

   296 		{

   297 		aProtocol = KProtocolInetTcp;

   298 		}

   299 	else if( aProtocolStr == KProtocolInetUdpStr() )

   300 		{

   301 		aProtocol = KProtocolInetUdp;

   302 		}

   303 	else

   304 		{

   305 		found = EFalse;

   306 		}

   307 

   308 	return found;

   309 	}

   310 

   311 TBool CT_DataCommsBase::GetAddrFamily( const TDesC& aAddrFamilyStr, TUint& aAddrFamily )

   312 	{

   313 	TBool found = ETrue;

   314 

   315 	if( aAddrFamilyStr == KAFUnspecStr() )

   316 		{

   317 		aAddrFamily = KAFUnspec;

   318 		}

   319 	else if( aAddrFamilyStr == KAfInetStr() )

   320 		{

   321 		aAddrFamily = KAfInet;

   322 		}

   323 	else if( aAddrFamilyStr == KAfInet6Str() )

   324 		{

   325 		aAddrFamily = KAfInet6;

   326 		}

   327 	else

   328 		{

   329 		found = EFalse;

   330 		}

   331 

   332 	return found;

   333 	}

   334 

   335 TBool CT_DataCommsBase::GetCapability( const TDesC& aCapabilityStr, TCapability& aCapability )

   336 	{

   337 	TBool found = ETrue;

   338 

   339 	if( aCapabilityStr == ECapabilityTCBStr() )

   340 		{

   341 		aCapability = ECapabilityTCB;

   342 		}

   343 	else if( aCapabilityStr == ECapabilityCommDDStr() )

   344 		{

   345 		aCapability = ECapabilityCommDD;

   346 		}

   347 	else if( aCapabilityStr == ECapabilityPowerMgmtStr() )

   348 		{

   349 		aCapability = ECapabilityPowerMgmt;

   350 		}

   351 	else if( aCapabilityStr == ECapabilityMultimediaDDStr() )

   352 		{

   353 		aCapability = ECapabilityMultimediaDD;

   354 		}

   355 	else if( aCapabilityStr == ECapabilityReadDeviceDataStr() )

   356 		{

   357 		aCapability = ECapabilityReadDeviceData;

   358 		}

   359 	else if( aCapabilityStr == ECapabilityWriteDeviceDataStr() )

   360 		{

   361 		aCapability = ECapabilityWriteDeviceData;

   362 		}

   363 	else if( aCapabilityStr == ECapabilityDRMStr() )

   364 		{

   365 		aCapability = ECapabilityDRM;

   366 		}

   367 	else if( aCapabilityStr == ECapabilityTrustedUIStr() )

   368 		{

   369 		aCapability = ECapabilityTrustedUI;

   370 		}

   371 	else if( aCapabilityStr == ECapabilityProtServStr() )

   372 		{

   373 		aCapability = ECapabilityProtServ;

   374 		}

   375 	else if( aCapabilityStr == ECapabilityDiskAdminStr() )

   376 		{

   377 		aCapability = ECapabilityDiskAdmin;

   378 		}

   379 	else if( aCapabilityStr == ECapabilityNetworkControlStr() )

   380 		{

   381 		aCapability = ECapabilityNetworkControl;

   382 		}

   383 	else if( aCapabilityStr == ECapabilityAllFilesStr() )

   384 		{

   385 		aCapability = ECapabilityAllFiles;

   386 		}

   387 	else if( aCapabilityStr == ECapabilitySwEventStr() )

   388 		{

   389 		aCapability = ECapabilitySwEvent;

   390 		}

   391 	else if( aCapabilityStr == ECapabilityNetworkServicesStr() )

   392 		{

   393 		aCapability = ECapabilityNetworkServices;

   394 		}

   395 	else if( aCapabilityStr == ECapabilityLocalServicesStr() )

   396 		{

   397 		aCapability = ECapabilityLocalServices;

   398 		}

   399 	else if( aCapabilityStr == ECapabilityReadUserDataStr() )

   400 		{

   401 		aCapability = ECapabilityReadUserData;

   402 		}

   403 	else if( aCapabilityStr == ECapabilityWriteUserDataStr() )

   404 		{

   405 		aCapability = ECapabilityWriteUserData;

   406 		}

   407 	else if( aCapabilityStr == ECapabilityLocationStr() )

   408 		{

   409 		aCapability = ECapabilityLocation;

   410 		}

   411 	else if( aCapabilityStr == ECapabilitySurroundingsDDStr() )

   412 		{

   413 		aCapability = ECapabilitySurroundingsDD;

   414 		}

   415 	else if( aCapabilityStr == ECapabilityUserEnvironmentStr() )

   416 		{

   417 		aCapability = ECapabilityUserEnvironment;

   418 		}

   419 	else if( aCapabilityStr == ECapability_LimitStr() )

   420 		{

   421 		aCapability = ECapability_Limit;

   422 		}

   423 	else if( aCapabilityStr == ECapability_HardLimitStr() )

   424 		{

   425 		aCapability = ECapability_HardLimit;

   426 		}

   427 	else if( aCapabilityStr == ECapability_NoneStr() )

   428 		{

   429 		aCapability = ECapability_None;

   430 		}

   431 	else if( aCapabilityStr == ECapability_DeniedStr() )

   432 		{

   433 		aCapability = ECapability_Denied;

   434 		}

   435 	else

   436 		{

   437 		found = EFalse;

   438 		}

   439 

   440 	return found;

   441 	}

   442 

   443 TBool CT_DataCommsBase::SubConnectionType( const TDesC& aSubConnTypeStr, RSubConnection::TSubConnType& aSubConnType)

   444 	{

   445 	TBool found = ETrue;

   446 

   447 	if( aSubConnTypeStr == KCreateNew() )

   448 		{

   449 		aSubConnType = RSubConnection::ECreateNew;

   450 		}

   451 	else if( aSubConnTypeStr == KAttachToDefault() )

   452 		{

   453 		aSubConnType = RSubConnection::EAttachToDefault;

   454 		}

   455 	else

   456 		{

   457 		found = EFalse;

   458 		}

   459 

   460 	return found;

   461 	}

   462 

   463 TBool CT_DataCommsBase::GetEventGroupUid(const TDesC& aEventGroupUidStr, TInt32& aEventGroupUid)

   464 	{

   465 	TBool found = ETrue;

   466 

   467 	if (aEventGroupUidStr == KSubConnGenericEventsImplUidStr())

   468 		{

   469 		aEventGroupUid = KSubConnGenericEventsImplUid;

   470 		}

   471 	else

   472 		{

   473 		found = EFalse;

   474 		}

   475 

   476 	return found;

   477 	}

   478 

   479 

   480 TBool CT_DataCommsBase::GetEventMaskBits(const TDesC& aConstantName, TUint32& aEventMask)

   481 	{

   482 	TBool	ret = ETrue;

   483 

   484 	if (aConstantName == KSubConGenericEventParamsGrantedStr())

   485 		{

   486 		aEventMask=KSubConGenericEventParamsGranted;

   487 		}

   488 	else if (aConstantName == KSubConGenericEventDataClientJoinedStr())

   489 		{

   490 		aEventMask=KSubConGenericEventDataClientJoined;

   491 		}

   492 	else if (aConstantName == KSubConGenericEventDataClientLeftStr())

   493 		{

   494 		aEventMask=KSubConGenericEventDataClientLeft;

   495 		}

   496 	else if (aConstantName == KSubConGenericEventSubConDownStr())

   497 		{

   498 		aEventMask=KSubConGenericEventSubConDown;

   499 		}

   500 	else if (aConstantName == KSubConGenericEventParamsChangedStr())

   501 		{

   502 		aEventMask=KSubConGenericEventParamsChanged;

   503 		}

   504 	else if (aConstantName == KSubConGenericEventParamsRejectedStr())

   505 		{

   506 		aEventMask=KSubConGenericEventParamsRejected;

   507 		}

   508 	else

   509 		{

   510 		TInt	location=aConstantName.Match(_L("*|*"));

   511 		if( location!=KErrNotFound )

   512 			{

   513 			//Converting Left part of the data

   514 			TPtrC	tempStr=aConstantName.Left(location);

   515 			ret=GetEventMaskBits(tempStr, aEventMask);

   516 

   517 			//Converting right data can be with another "|"

   518 			tempStr.Set(aConstantName.Mid(location+1));

   519 

   520 			TUint32	tmp;

   521 			if ( GetEventMaskBits(tempStr, tmp) )

   522 				{

   523 				aEventMask |= tmp;

   524 				}

   525 			else

   526 				{

   527 				ret = EFalse;

   528 				}

   529 			}

   530 		else

   531 			{

   532 			TInt	flagInt;

   533 			TLex	lex(aConstantName);

   534 			if (lex.Val(flagInt)==KErrNone)

   535 				{

   536 				aEventMask=flagInt;

   537 				}

   538 			else

   539 				{

   540 				ret=EFalse;

   541 				ERR_PRINTF2(_L("Given flag (%S) is invalid"), &aConstantName);

   542 				SetBlockResult(EFail);

   543 				}

   544 			}

   545 		}

   546 

   547 	return ret;

   548 	}

   549 

   550 TBool CT_DataCommsBase::ParameterSetType( const TDesC& aParameterSetTypeStr, CSubConParameterFamily::TParameterSetType& aParameterSetType )

   551 	{

   552 	TBool found = ETrue;

   553 

   554 	if( aParameterSetTypeStr == KAcceptable() )

   555 		{

   556 		aParameterSetType = CSubConParameterFamily::EAcceptable;

   557 		}

   558 	else if( aParameterSetTypeStr == KRequested() )

   559 		{

   560 		aParameterSetType = CSubConParameterFamily::ERequested;

   561 		}

   562 	else if( aParameterSetTypeStr == KGranted() )

   563 		{

   564 		aParameterSetType = CSubConParameterFamily::EGranted;

   565 		}

   566 	else

   567 		{

   568 		found = EFalse;

   569 		}

   570 

   571 	return found;

   572 	}

   573 

   574 TUint32 CT_DataCommsBase::GetLowPowerMode(const TDesC& aConstantName)

   575 	{

   576 	_LIT(KEActiveMode,							"EActiveMode");

   577 	_LIT(KEHoldMode,							"EHoldMode");

   578 	_LIT(KESniffMode,							"ESniffMode");

   579 	_LIT(KEParkMode,							"EParkMode");

   580 	_LIT(KEScatterMode,							"EScatterMode");

   581 	//_LIT(KEAnyLowPowerMode,						"EAnyLowPowerMode");

   582 	

   583 	TUint32 lowPowerMode = EAnyLowPowerMode;

   584 	

   585 	if (aConstantName == KEActiveMode)

   586 		{

   587 		lowPowerMode = EActiveMode;

   588 		}

   589 	else if (aConstantName == KEHoldMode)

   590 		{

   591 		lowPowerMode = EHoldMode;

   592 		}

   593 	else if (aConstantName == KESniffMode)

   594 		{

   595 		lowPowerMode = ESniffMode;

   596 		}

   597 	else if (aConstantName == KEParkMode)

   598 		{

   599 		lowPowerMode = EParkMode;

   600 		}

   601 	else if (aConstantName == KEScatterMode)

   602 		{

   603 		lowPowerMode = EScatterMode;

   604 		}

   605 	else

   606 		{

   607 		lowPowerMode = EAnyLowPowerMode;

   608 		}

   609 		

   610 	return lowPowerMode;

   611 	}

   612 

   613 TBool CT_DataCommsBase::GetTShutdown(const TDesC& aConstantName, RSocket::TShutdown& aShutdown)

   614 	{

   615 	_LIT(KNormal,								"ENormal");

   616 	_LIT(KStopInput,							"EStopInput");

   617 	_LIT(KStopOutput,							"EStopOutput");

   618 	_LIT(KImmediate,							"EImmediate");

   619 

   620 	TBool	ret=ETrue;

   621 

   622 	if (aConstantName == KNormal)

   623 		{

   624 		// Complete when socket output/input stopped.

   625 		aShutdown=RSocket::ENormal;

   626 		}

   627 	else if (aConstantName == KStopInput)

   628 		{

   629 		// Stop socket input and complete when input is stopped.

   630 		aShutdown=RSocket::EStopInput;

   631 		}

   632 	else if (aConstantName == KStopOutput)

   633 		{

   634 		// Stop socket output and complete when output is stopped.

   635 		aShutdown=RSocket::EStopOutput;

   636 		}

   637 	else if (aConstantName == KImmediate)

   638 		{

   639 		// Stop socket input/output and complete (abortive close).

   640 		aShutdown=RSocket::EImmediate;

   641 		}

   642 	else

   643 		{

   644 		// If we did not find the value go for default

   645 		// Complete when socket output/input stopped.

   646 		ret = EFalse;

   647 		aShutdown=RSocket::ENormal;

   648 		}

   649 

   650 	return ret;

   651 	}

   652 

   653 TInt CT_DataCommsBase::GetTBTPacketType(const TDesC& aConstantName)

   654 	{

   655 	_LIT(KEPacketsDM1,							"EPacketsDM1");

   656 	_LIT(KEPacketsDH1,							"EPacketsDH1");

   657 	_LIT(KEPacketsDM3,							"EPacketsDM1");

   658 	_LIT(KEPacketsDH3,							"EPacketsDH1");

   659 	_LIT(KEPacketsDM5,							"EPacketsDM1");

   660 	_LIT(KEPacketsDH5,							"EPacketsDH1");

   661 	_LIT(KEPacketsHV1,							"EPacketsHV1");

   662 	_LIT(KEPacketsHV2,							"EPacketsHV2");

   663 	_LIT(KEPacketsHV3,							"EPacketsHV3");

   664 	_LIT(KEAnyACLPacket,						"EAnyACLPacket");

   665 	_LIT(KEAnySCOPacket,						"EAnySCOPacket");

   666 

   667 	TInt packetType = EAnyPacket;

   668 	

   669 	//Description

   670 	//Bluetooth SIG specified values for indicating packet types.

   671 	//

   672 	//DM1, DH1, DM3, DH3, DM5, DH5 are ACL packet types

   673 	//HV1, HV2, HV3 are SCO (synchronous link) packet types

   674 	//

   675 	//

   676 

   677 	//EPacketsDM1

   678 	if (aConstantName == KEPacketsDM1)

   679 		{

   680 		packetType = EPacketsDM1;

   681 		}

   682 	//DH1 ACL packet type

   683 	else if (aConstantName == KEPacketsDH1)

   684 		{

   685 		packetType = EPacketsDH1;

   686 		}

   687 	//EPacketsDM3

   688 	else if (aConstantName == KEPacketsDM3)

   689 		{

   690 		packetType = EPacketsDM3;

   691 		}

   692 	//DH3 ACL packet type

   693 	else if (aConstantName == KEPacketsDH3)

   694 		{

   695 		packetType = EPacketsDH3;

   696 		}

   697 	//EPacketsDM5

   698 	else if (aConstantName == KEPacketsDM5)

   699 		{

   700 		packetType = EPacketsDM5;

   701 		}

   702 	//DH5 ACL packet type

   703 	else if (aConstantName == KEPacketsDH5)

   704 		{

   705 		packetType = EPacketsDH5;

   706 		}

   707 	//HV1 SCO packet type

   708 	else if (aConstantName == KEPacketsHV1)

   709 		{

   710 		packetType = EPacketsHV1;

   711 		}

   712 	//HV2 SCO packet type

   713  	else if (aConstantName == KEPacketsHV2)

   714 		{

   715 		packetType = EPacketsHV2;

   716 		}

   717 	//HV3 SCO packet type

   718  	else if (aConstantName == KEPacketsHV3)

   719 		{

   720 		packetType = EPacketsHV3;

   721 		}

   722 

   723 	//TBTPacketTypeCombinations

   724 	//Description

   725 	//Bitmask values to help request combinations of packets.

   726 

   727 	//Any ACL packet

   728   	else if (aConstantName == KEAnyACLPacket)

   729 		{

   730 		packetType = EAnyACLPacket;

   731 		}

   732 	//Any SCO packet

   733   	else if (aConstantName == KEAnySCOPacket)

   734 		{

   735 		packetType = EAnySCOPacket;

   736 		}

   737 	//Any packet

   738 	else

   739 		{

   740 		packetType = EAnyPacket;

   741 		}

   742 		

   743 	return packetType;

   744 	}

   745 

   746 

   747 TUint32  CT_DataCommsBase::GetLinkStateNotifierBits(const TDesC& aConstantName)

   748 	{

   749 	_LIT(KENotifyMaster,						"ENotifyMaster");

   750 	_LIT(KENotifySlave,							"ENotifySlave");

   751 

   752 	_LIT(KENotifyActiveMode,					"ENotifyActiveMode");

   753 	_LIT(KENotifySniffMode,						"ENotifySniffMode");

   754 	_LIT(KENotifyParkMode,						"ENotifyParkMode");

   755 	_LIT(KENotifyHoldMode,						"ENotifyHoldMode");

   756 

   757 	_LIT(KENotifyMaxSlots1,						"ENotifyMaxSlots1");

   758 	_LIT(KENotifyMaxSlots3,						"ENotifyMaxSlots3");

   759 	_LIT(KENotifyMaxSlots5,						"ENotifyMaxSlots5");

   760 

   761 	_LIT(KENotifyPacketsDM1,					"ENotifyPacketsDM1");

   762 	_LIT(KENotifyPacketsDH1,					"ENotifyPacketsDH1");

   763 	_LIT(KENotifyPacketsDM3,					"ENotifyPacketsDM3");

   764 	_LIT(KENotifyPacketsDH3,					"ENotifyPacketsDH3");

   765 	_LIT(KENotifyPacketsDM5,					"ENotifyPacketsDM5");

   766 	_LIT(KENotifyPacketsDH5,					"ENotifyPacketsDH5");

   767 

   768 	_LIT(KENotifyPacketsHV1,					"ENotifyPacketsHV1");

   769 	_LIT(KENotifyPacketsHV2,					"ENotifyPacketsHV2");

   770 	_LIT(KENotifyPacketsHV3,					"ENotifyPacketsHV3");

   771 

   772 	_LIT(KENotifyAuthenticationComplete,		"ENotifyAuthenticationComplete");

   773 	_LIT(KENotifyEncryptionChangeOn,			"ENotifyEncryptionChangeOn");

   774 	_LIT(KENotifyEncryptionChangeOff,			"ENotifyEncryptionChangeOff");

   775 

   776 

   777 	_LIT(KENotifyPhysicalLinkUp,				"ENotifyPhysicalLinkUp");

   778 	_LIT(KENotifyPhysicalLinkDown,				"ENotifyPhysicalLinkDown");

   779 	_LIT(KENotifyPhysicalLinkError,				"ENotifyPhysicalLinkError");

   780 

   781 	_LIT(KENotifySCOLinkUp,						"ENotifySCOLinkUp");

   782 	_LIT(KENotifySCOLinkDown,					"ENotifySCOLinkDown");

   783 	_LIT(KENotifySCOLinkError,					"ENotifySCOLinkError");

   784 	

   785 	TUint32 linkStateNotifierBits = 0;

   786 

   787 	// This is from BTTypes.h

   788 

   789 	// Bitmask values for notifying/requesting notification of the state of a physical link.

   790 	//

   791 	// These values have a two fold purpose:

   792 	// 1) They can be used along with TBTPhysicalLinkStateNotifierCombinations to specify

   793 	// a set of baseband change events for which notification is desired.

   794 	// 2) They can be used to notify the state of a physical link or a subset of that state.

   795 	// For example if only mode change events are being monitored, then at each mode change event

   796 	// only the bit reperesenting the new mode will be returned, however if the whole link state

   797 	// is required, then a combination of bit values indicating that state will be returned.

   798 	//

   799 	// THESE BIT VALUES MUST ONLY BE USED WHEN REQUESTING NOTIFICATION, OR WHEN PARSING THE

   800 	// RESULTS OF A NOTIFICATION. All other baseband state activities should use one of the

   801 	// appropriate Bluetooth SIG specified enums

   802 	// TBTBasebandRole, TBTLinkMode, TBTLinkModeCombinations, TBTPacketType,

   803 	// TBTPacketTypeCombinations

   804 	//

   805 

   806 	//Master

   807 	if (aConstantName == KENotifyMaster)

   808 		{

   809 		linkStateNotifierBits = ENotifyMaster;

   810 		}

   811 	//Slave

   812 	else if (aConstantName == KENotifySlave)

   813 		{

   814 		linkStateNotifierBits = ENotifySlave;

   815 		}

   816 

   817 	//Active Mode

   818 	else if (aConstantName == KENotifyActiveMode)

   819 		{

   820 		linkStateNotifierBits = ENotifyActiveMode;

   821 		}

   822 	//Sniff mode

   823 	else if (aConstantName == KENotifySniffMode)

   824 		{

   825 		linkStateNotifierBits = ENotifySniffMode;

   826 		}

   827 	//Park mode

   828 	else if (aConstantName == KENotifyParkMode)

   829 		{

   830 		linkStateNotifierBits = ENotifyParkMode;

   831 		}

   832 	//Hold mode

   833 	else if (aConstantName == KENotifyHoldMode)

   834 		{

   835 		linkStateNotifierBits = ENotifyHoldMode;

   836 		}

   837 

   838 	//Max slots 1

   839 	else if (aConstantName == KENotifyMaxSlots1)

   840 		{

   841 		linkStateNotifierBits = ENotifyMaxSlots1;

   842 		}

   843 	//Max slots 3

   844 	else if (aConstantName == KENotifyMaxSlots3)

   845 		{

   846 		linkStateNotifierBits = ENotifyMaxSlots3;

   847 		}

   848 	//Max slots 5

   849 	else if (aConstantName == KENotifyMaxSlots5)

   850 		{

   851 		linkStateNotifierBits = ENotifyMaxSlots5;

   852 		}

   853 

   854 

   855 	//Packets DM1

   856 	else if (aConstantName == KENotifyPacketsDM1)

   857 		{

   858 		linkStateNotifierBits = ENotifyPacketsDM1;

   859 		}

   860 	//Packets DH1

   861 	else if (aConstantName == KENotifyPacketsDH1)

   862 		{

   863 		linkStateNotifierBits = ENotifyPacketsDH1;

   864 		}

   865 	//Packets DM3

   866 	else if (aConstantName == KENotifyPacketsDM3)

   867 		{

   868 		linkStateNotifierBits = ENotifyPacketsDM3;

   869 		}

   870 	//Packets DH3

   871 	else if (aConstantName == KENotifyPacketsDH3)

   872 		{

   873 		linkStateNotifierBits = ENotifyPacketsDH3;

   874 		}

   875 	//Packets DM5

   876 	else if (aConstantName == KENotifyPacketsDM5)

   877 		{

   878 		linkStateNotifierBits = ENotifyPacketsDM5;

   879 		}

   880 	//Packets DH5

   881 	else if (aConstantName == KENotifyPacketsDH5)

   882 		{

   883 		linkStateNotifierBits = ENotifyPacketsDH5;

   884 		}

   885 

   886 	//HV1

   887 	else if (aConstantName == KENotifyPacketsHV1)

   888 		{

   889 		linkStateNotifierBits = ENotifyPacketsHV1;

   890 		}

   891 	//HV2

   892 	else if (aConstantName == KENotifyPacketsHV2)

   893 		{

   894 		linkStateNotifierBits = ENotifyPacketsHV2;

   895 		}

   896 	//HV3

   897 	else if (aConstantName == KENotifyPacketsHV3)

   898 		{

   899 		linkStateNotifierBits = ENotifyPacketsHV3;

   900 		}

   901 

   902 	//Authentication Complete

   903 	else if (aConstantName == KENotifyAuthenticationComplete)

   904 		{

   905 		linkStateNotifierBits = ENotifyAuthenticationComplete;

   906 		}

   907 	//Encryption Change On

   908 	else if (aConstantName == KENotifyEncryptionChangeOn)

   909 		{

   910 		linkStateNotifierBits = ENotifyEncryptionChangeOn;

   911 		}

   912 	//Encryption Change Off

   913 	else if (aConstantName == KENotifyEncryptionChangeOff)

   914 		{

   915 		linkStateNotifierBits = ENotifyEncryptionChangeOff;

   916 		}

   917 	//Physical Link Up

   918 	else if (aConstantName == KENotifyPhysicalLinkUp)

   919 		{

   920 		linkStateNotifierBits = ENotifyPhysicalLinkUp;

   921 		}

   922 	//Physical Link Down

   923 	else if (aConstantName == KENotifyPhysicalLinkDown)

   924 		{

   925 		linkStateNotifierBits = ENotifyPhysicalLinkDown;

   926 		}

   927 	//Physical Link Error

   928 	else if (aConstantName == KENotifyPhysicalLinkError)

   929 		{

   930 		linkStateNotifierBits = ENotifyPhysicalLinkError;

   931 		}

   932 

   933 	//SCO Link Up

   934 	else if (aConstantName == KENotifySCOLinkUp)

   935 		{

   936 		linkStateNotifierBits = ENotifySCOLinkUp;

   937 		}

   938 	//SCO Link Down

   939 	else if (aConstantName == KENotifySCOLinkDown)

   940 		{

   941 		linkStateNotifierBits = ENotifySCOLinkDown;

   942 		}

   943 	//SCO Link Error

   944 	else if (aConstantName == KENotifySCOLinkError)

   945 		{

   946 		linkStateNotifierBits = ENotifySCOLinkError;

   947 		}

   948 	else

   949 		{

   950 		linkStateNotifierBits = 0;

   951 		}

   952 		

   953 	return linkStateNotifierBits;

   954 	}

   955 

   956 // method splitted in blocks to save stack space

   957 TBool CT_DataCommsBase::GetIntValue(const TDesC& aConstantName, TInt& aValue)

   958 	{

   959 	TBool	ret= ETrue;

   960 	// ************************************************************************

   961 	// bt_sock.h

   962 	// ************************************************************************

   963 	_LIT(KBTAddrFamilyName,							"KBTAddrFamily");

   964 	_LIT(KBTLinkManagerName,						"KBTLinkManager");

   965 	_LIT(KL2CAPName,								"KL2CAP");

   966 	_LIT(KRFCOMMName,								"KRFCOMM");

   967 	_LIT(KSDPName,									"KSDP");

   968 	_LIT(KAVCTPName,								"KAVCTP");

   969 	_LIT(KTCIL2CAPName,								"KTCIL2CAP");

   970 	_LIT(KBTMajorName,								"KBTMajor");

   971 	_LIT(KBTMinorName,								"KBTMinor");

   972 	_LIT(KBTBuildName,								"KBTBuild");

   973 	_LIT(KSolInetIpName,							"KSolInetIp");

   974 	_LIT(KSolBtBlogName,							"KSolBtBlog");

   975 	_LIT(KSolBtHCIName,								"KSolBtHCI");

   976 	_LIT(KSolBtLMName,								"KSolBtLM");

   977 	_LIT(KSolBtL2CAPName,							"KSolBtL2CAP");

   978 	_LIT(KSolBtRFCOMMName,							"KSolBtRFCOMM");

   979 	_LIT(KSolBtAVCTPName,							"KSolBtAVCTP");

   980 	_LIT(KSolBtACLName,								"KSolBtACL");

   981 	_LIT(KSolBtAVDTPSignallingName,					"KSolBtAVDTPSignalling");

   982 	_LIT(KSolBtAVDTPMediaName,						"KSolBtAVDTPMedia");

   983 	_LIT(KSolBtAVDTPReportingName,					"KSolBtAVDTPReporting");

   984 	_LIT(KSolBtAVDTPRecoveryName,					"KSolBtAVDTPRecovery");

   985 	_LIT(KSolBtAVDTPInternalName,					"KSolBtAVDTPInternal");

   986 	_LIT(KSolBtLMProxyName,							"KSolBtLMProxy");

   987 	_LIT(KSolBtSAPBaseName,							"KSolBtSAPBase");

   988 	_LIT(KSCOListenQueSizeName,						"KSCOListenQueSize");

   989 	_LIT(KL2MinMTUName,								"KL2MinMTU");

   990 	_LIT(KMaxPSMName,								"KMaxPSM");

   991 	_LIT(KMinUserPSMName,							"KMinUserPSM");

   992 	_LIT(KMinPSMName,								"KMinPSM");

   993 	_LIT(KHostResInquiryName,						"KHostResInquiry");

   994 	_LIT(KHostResNameName,							"KHostResName");

   995 	_LIT(KHostResIgnoreCacheName,					"KHostResIgnoreCache");

   996 	_LIT(KHostResCacheName,							"KHostResCache");

   997 	_LIT(KL2CAPEchoRequestIoctlName,				"KL2CAPEchoRequestIoctl");

   998 	_LIT(KL2CAPIncomingMTUIoctlName,				"KL2CAPIncomingMTUIoctl");

   999 	_LIT(KL2CAPOutgoingMTUIoctlName,				"KL2CAPOutgoingMTUIoctl");

  1000 	_LIT(KL2CAPUpdateChannelConfigIoctlName,		"KL2CAPUpdateChannelConfigIoctl");

  1001 	_LIT(KDefaultBasebandConnectionTimeoutName,		"KDefaultBasebandConnectionTimeout");

  1002 	_LIT(KLMAddSCOConnIoctlName,					"KLMAddSCOConnIoctl");

  1003 	_LIT(KHCIRemoveSCOConnIoctlName,				"KHCIRemoveSCOConnIoctl");

  1004 	_LIT(KHCIChangePacketTypeIoctlName,				"KHCIChangePacketTypeIoctl");

  1005 	_LIT(KHCIAuthRequestIoctlName,					"KHCIAuthRequestIoctl");

  1006 	_LIT(KHCIEncryptIoctlName,						"KHCIAuthRequestIoctl");

  1007 	_LIT(KHCIChangeLinkKeyIoctlName,				"KHCIChangeLinkKeyIoctl");

  1008 	_LIT(KHCIMasterLinkKeyIoctlName,				"KHCIMasterLinkKeyIoctl");

  1009 	_LIT(KHCIHoldModeIoctlName,						"KHCIHoldModeIoctl");

  1010 	_LIT(KHCISniffModeIoctlName,					"KHCISniffModeIoctl");

  1011 	_LIT(KHCIExitSniffModeIoctlName,				"KHCIExitSniffModeIoctl");

  1012 	_LIT(KHCIParkModeIoctlName,						"KHCIParkModeIoctl");

  1013 	_LIT(KHCIExitParkModeIoctlName,					"KHCIExitParkModeIoctl");

  1014 	_LIT(KHCIReadPageTimeoutIoctlName,				"KHCIReadPageTimeoutIoctl");

  1015 	_LIT(KHCIWritePageTimeoutIoctlName,				"KHCIWritePageTimeoutIoctl");

  1016 	_LIT(KHCIReadScanEnableIoctlName,				"KHCIReadScanEnableIoctl");

  1017 	_LIT(KHCIWriteScanEnableIoctlName,				"KHCIWriteScanEnableIoctl");

  1018 	_LIT(KHCIReadDeviceClassIoctlName,				"KHCIReadDeviceClassIoctl");

  1019 	_LIT(KHCIWriteDeviceClassIoctlName,				"KHCIWriteDeviceClassIoctl");

  1020 	_LIT(KHCIReadVoiceSettingIoctlName,				"KHCIReadVoiceSettingIoctl");

  1021 	_LIT(KHCIWriteVoiceSettingIoctlName,			"KHCIWriteVoiceSettingIoctl");

  1022 	_LIT(KHCIReadHoldModeActivityIoctlName,			"KHCIReadHoldModeActivityIoctl");

  1023 	_LIT(KHCIWriteHoldModeActivityIoctlName,		"KHCIWriteHoldModeActivityIoctl");

  1024 	_LIT(KHCILocalVersionIoctlName,					"KHCILocalVersionIoctl");

  1025 	_LIT(KHCILocalFeaturesIoctlName,				"KHCILocalFeaturesIoctl");

  1026 	_LIT(KHCICountryCodeIoctlName,					"KHCICountryCodeIoctl");

  1027 	_LIT(KHCILocalAddressIoctlName,					"KHCILocalAddressIoctl");

  1028 	_LIT(KHCIWriteDiscoverabilityIoctlName,			"KHCIWriteDiscoverabilityIoctl");

  1029 	_LIT(KHCIReadDiscoverabilityIoctlName,			"KHCIReadDiscoverabilityIoctl");

  1030 	_LIT(KHCIReadAuthenticationEnableIoctlName,		"KHCIReadAuthenticationEnableIoctl");

  1031 	_LIT(KHCIWriteAuthenticationEnableIoctlName,	"KHCIWriteAuthenticationEnableIoctl");

  1032 	_LIT(KL2CAPPassiveAutoBindName,					"KL2CAPPassiveAutoBind");

  1033 	_LIT(KRFCOMMModemStatusCmdIoctlName,			"KRFCOMMModemStatusCmdIoctl");

  1034 	_LIT(KRFCOMMRemoteLineStatusCmdIoctlName,		"KRFCOMMRemoteLineStatusCmdIoctl");

  1035 	_LIT(KRFCOMMRemotePortNegCmdIoctlName,			"KRFCOMMRemotePortNegCmdIoctl");

  1036 	_LIT(KRFCOMMRemotePortNegRequestIoctlName,		"KRFCOMMRemotePortNegRequestIoctl");

  1037 	_LIT(KRFCOMMConfigChangeIndicationIoctlName,	"KRFCOMMConfigChangeIndicationIoctl");

  1038 	_LIT(KRFCOMMLocalPortParameterName,				"KRFCOMMLocalPortParameter");

  1039 	_LIT(KRFCOMMGetAvailableServerChannelName,		"KRFCOMMGetAvailableServerChannel");

  1040 	_LIT(KRFCOMMMaximumSupportedMTUName,			"KRFCOMMMaximumSupportedMTU");

  1041 	_LIT(KRFCOMMGetDebug1Name,						"KRFCOMMGetDebug1");

  1042 	_LIT(KRFCOMMGetRemoteModemStatusName,			"KRFCOMMGetRemoteModemStatus");

  1043 	_LIT(KRFCOMMGetTransmitCreditName,				"KRFCOMMGetTransmitCredit");

  1044 	_LIT(KRFCOMMGetReceiveCreditName,				"KRFCOMMGetReceiveCredit");

  1045 	_LIT(KRFCOMMGetReUsedCountName,					"KRFCOMMGetReUsedCount");

  1046 	_LIT(KRFCOMMFlowTypeCBFCName,					"KRFCOMMFlowTypeCBFC");

  1047 	_LIT(KRFCOMMLocalModemStatusName,				"KRFCOMMLocalModemStatus");

  1048 	_LIT(KErrNoneName,								"KErrNone");

  1049 	_LIT(KErrCancelName,							"KErrCancel");

  1050 	_LIT(KErrBadHandleName,							"KErrBadHandle");

  1051 	_LIT(KZero,										"Zero");

  1052 	_LIT(KOne,										"One");

  1053 	_LIT(ELMOutboundACLSizeName,					"ELMOutboundACLSize");

  1054 	_LIT(ELMInboundACLSizeName,						"ELMInboundACLSize");

  1055 	_LIT(KLMGetACLHandleName,						"KLMGetACLHandle");

  1056 	_LIT(KLMGetACLLinkCountName,					"KLMGetACLLinkCount");

  1057 	_LIT(KLMGetACLLinkArrayName,					"KLMGetACLLinkArray");

  1058 	_LIT(KLMSetBasebandConnectionPolicyName,		"KLMSetBasebandConnectionPolicy");

  1059 	_LIT(KLMGetBasebandHandleName,					"KLMGetBasebandHandle");

  1060 	_LIT(EBBSubscribePhysicalLinkName,				"EBBSubscribePhysicalLink");

  1061 	_LIT(EBBBeginRawName,							"EBBBeginRaw");

  1062 	_LIT(EBBRequestRoleMasterName,					"EBBRequestRoleMaster");

  1063 	_LIT(EBBRequestRoleSlaveName,					"EBBRequestRoleSlave");

  1064 	_LIT(EBBCancelModeRequestName,					"EBBCancelModeRequest");

  1065 	_LIT(EBBRequestSniffName,						"EBBRequestSniff");

  1066 	_LIT(EBBRequestParkName,						"EBBRequestPark");

  1067 	_LIT(EBBRequestPreventRoleChangeName,			"EBBRequestPreventRoleChange");

  1068 	_LIT(EBBRequestAllowRoleChangeName,				"EBBRequestAllowRoleChange");

  1069 	_LIT(EBBRequestChangeSupportedPacketTypesName,	"EBBRequestChangeSupportedPacketTypes");

  1070 	_LIT(EBBEnumeratePhysicalLinksName,				"EBBEnumeratePhysicalLinks");

  1071 	_LIT(EBBGetPhysicalLinkStateName,				"EBBGetPhysicalLinkState");

  1072 	_LIT(EBBGetSniffIntervalName,					"EBBGetSniffInterval");

  1073 	_LIT(EBBRequestLinkAuthenticationName,			"EBBRequestLinkAuthentication");

  1074 	_LIT(EBBRequestPreventSniffName,				"EBBRequestPreventSniff");

  1075 	_LIT(EBBRequestPreventHoldName,					"EBBRequestPreventHold");

  1076 	_LIT(EBBRequestPreventParkName,					"EBBRequestPreventPark");

  1077 	_LIT(EBBRequestPreventAllLowPowerModesName,		"EBBRequestPreventAllLowPowerModes");

  1078 	_LIT(EBBRequestAllowSniffName,					"EBBRequestAllowSniff");

  1079 	_LIT(EBBRequestAllowHoldName,					"EBBRequestAllowHold");

  1080 	_LIT(EBBRequestAllowParkName,					"EBBRequestAllowPark");

  1081 	_LIT(EBBRequestAllowAllLowPowerModesName,		"EBBRequestAllowAllLowPowerModes");

  1082 	_LIT(KBTRegisterCodServiceName,					"KBTRegisterCodService");

  1083 	_LIT(KBTSecurityDeviceOverrideName,				"KBTSecurityDeviceOverride");

  1084 	_LIT(KESockDefaultMessageSlotsName,				"KESockDefaultMessageSlots");

  1085 	_LIT(KUseEmbeddedUniqueIdName,					"KUseEmbeddedUniqueId");

  1086 	_LIT(KConnProgressDefaultName,					"KConnProgressDefault");

  1087 	_LIT(KMaxSockAddrSizeName,						"KMaxSockAddrSize");

  1088 	_LIT(KAfInetName,								"KAfInet");

  1089 	_LIT(KAfInet6Name,								"KAfInet6");

  1090 	_LIT(KAFUnspecName,								"KAFUnspec");

  1091 	_LIT(KSockStreamName,							"KSockStream");

  1092 	_LIT(KSockDatagramName,							"KSockDatagram");

  1093 	_LIT(KSockSeqPacketName,						"KSockSeqPacket");

  1094 	_LIT(KSockRawName,								"KSockRaw");

  1095 	_LIT(KSOLSocketName,							"KSOLSocket");

  1096 	_LIT(KLevelUnspecifiedName,						"KLevelUnspecified");

  1097 	_LIT(KSODebugName,								"KSODebug");

  1098 	_LIT(KSORecvBufName,							"KSORecvBuf");

  1099 	_LIT(KSOSendBufName,							"KSOSendBuf");

  1100 	_LIT(KSoReuseAddrName,							"KSoReuseAddr");

  1101 	_LIT(KSONonBlockingIOName,						"KSONonBlockingIO");

  1102 	_LIT(KSOBlockingIOName,							"KSOBlockingIO");

  1103 	_LIT(KSOSelectPollName,							"KSOSelectPoll");

  1104 	_LIT(KSOReadBytesPendingName,					"KSOReadBytesPending");

  1105 	_LIT(KSOUrgentDataOffsetName,					"KSOUrgentDataOffset");

  1106 	_LIT(KSOSelectLastErrorName,					"KSOSelectLastError");

  1107 	_LIT(KSOEnableTransferName,						"KSOEnableTransfer");

  1108 	_LIT(KSODisableTransferName,					"KSODisableTransfer");

  1109 	_LIT(KSocketBufSizeUndefinedName,				"KSocketBufSizeUndefined");

  1110 	_LIT(KSocketDefaultBufferSizeName,				"KSocketDefaultBufferSize");

  1111 	_LIT(KSocketInternalOptionBitName,				"KSocketInternalOptionBit");

  1112 	_LIT(KIOctlSelectName,							"KIOctlSelect");

  1113 	_LIT(KSockSelectReadName,						"KSockSelectRead");

  1114 	_LIT(KSockSelectWriteName,						"KSockSelectWrite");

  1115 	_LIT(KSockSelectExceptName,						"KSockSelectExcept");

  1116 	_LIT(KSockSelectReadContinuationName,			"KSockSelectReadContinuation");

  1117 	_LIT(KSockWriteUrgentName,						"KSockWriteUrgent");

  1118 	_LIT(KSocketInternalWriteBitName,				"KSocketInternalWriteBit");

  1119 	_LIT(KSockWriteSystemMaskName,					"KSockWriteSystemMask");

  1120 	_LIT(KSockReadPeekName,							"KSockReadPeek");

  1121 	_LIT(KSocketInternalReadBitName,				"KSocketInternalReadBit");

  1122 	_LIT(KSockReadContinuationName,					"KSockReadContinuation");

  1123 	_LIT(KSIConnectionLessName,						"KSIConnectionLess");

  1124 	_LIT(KSIReliableName,							"KSIReliable");

  1125 	_LIT(KSIInOrderName,							"KSIInOrder");

  1126 	_LIT(KSIMessageBasedName,						"KSIMessageBased");

  1127 	_LIT(KSIDatagramName,							"KSIDatagram");

  1128 	_LIT(KSIStreamBasedName,						"KSIStreamBased");

  1129 	_LIT(KSIPseudoStreamName,						"KSIPseudoStream");

  1130 	_LIT(KSIUrgentDataName,							"KSIUrgentData");

  1131 	_LIT(KSIConnectDataName,						"KSIConnectData");

  1132 	_LIT(KSIDisconnectDataName,						"KSIDisconnectData");

  1133 	_LIT(KSIBroadcastName,							"KSIBroadcast");

  1134 	_LIT(KSIMultiPointName,							"KSIMultiPoint");

  1135 	_LIT(KSIQOSName,								"KSIQOS");