diff -r 000000000000 -r 29b1cd4cb562 bluetoothapitest/bluetoothsvs/T_BTSockAPI/src/T_CBluetoothSocketData.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bluetoothapitest/bluetoothsvs/T_BTSockAPI/src/T_CBluetoothSocketData.cpp Fri Jan 15 08:13:17 2010 +0200 @@ -0,0 +1,2743 @@ +/* +* 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_CBluetoothSocketData.h" +#include "T_BTUtil.h" +#include "T_TBTSockAddrChild.h" +#include "T_BTDevAddrData.h" +#include "T_BTSockAddrData.h" + +// EPOC includes +#include + + +/*@{*/ +/// Constant Literals used. + +/// Parameters +_LIT(KExpectedReply, "expectedreply"); +_LIT(KCBluetoothSocket, "cbluetoothsocket"); +_LIT(KConnectData, "connectdata"); +_LIT(KData, "data"); +_LIT(KDesOption, "desoption"); +_LIT(KDisconnectData, "disconnectData"); +_LIT(KEquals, "equals"); +_LIT(KExpectNull, "expectnull"); +_LIT(KFlags, "flags"); +_LIT(KGetDes, "getdes"); +_LIT(KIntOption, "intoption"); +_LIT(KNamedIntOption, "namedintoption"); +_LIT(KNamedProtocol, "named_protocol"); +_LIT(KOptionLevel, "optionlevel"); +_LIT(KOptionName, "optionname"); +_LIT(KPort, "port"); +_LIT(KProtocol, "protocol"); +_LIT(KQueueSize, "queuesize"); +_LIT(KRSocket, "rsocket"); +_LIT(KServiceBits, "servicebits"); +_LIT(KSockType, "socktype"); +_LIT(KTBTSockAddr, "tbtsockaddr"); +_LIT(KTSockAddr, "tsockaddr"); +_LIT(KUid, "uid"); +_LIT(KUseAccept2, "useaccept2"); +_LIT(KUseAlternateNotifier, "usealternatenotifier"); +_LIT(KUseDeprecated, "usedeprecated"); +_LIT(KUseRecv2, "userecv2"); +_LIT(KUseSend2, "usesend2"); +_LIT(KHexBTAddrL, "hex_btaddr_l"); +_LIT(KHexBTAddrR, "hex_btaddr_r"); +_LIT(KTBTDevAddr, "tbtdevaddr"); +_LIT(KCallTwice, "calltwice"); +_LIT(KMTUSize, "mtusize"); +_LIT(KState, "state"); +_LIT(KConstructorType, "constructortype"); +_LIT(KSniffMode, "sniffmode"); +_LIT(KSniffDelay, "sniffdelay"); + +/// CBluetoothSocket +_LIT(KCmdAccept, "Accept"); +_LIT(KCmdActivateBasebandEventNotifier, "ActivateBasebandEventNotifier"); +_LIT(KCmdActivateParkRequester, "ActivateParkRequester"); +_LIT(KCmdActivateSniffRequester, "ActivateSniffRequester"); +_LIT(KCmdAllowLowPowerModes, "AllowLowPowerModes"); +_LIT(KCmdAllowRoleSwitch, "AllowRoleSwitch"); +_LIT(KCmdBind, "Bind"); +_LIT(KCmdCancelAccept, "CancelAccept"); +_LIT(KCmdCancelAll, "CancelAll"); +_LIT(KCmdCancelBasebandEventNotifier, "CancelBasebandEventNotifier"); +_LIT(KCmdCancelConnect, "CancelConnect"); +_LIT(KCmdCancelIoctl, "CancelIoctl"); +_LIT(KCmdCancelLowPowerModeRequester, "CancelLowPowerModeRequester"); +_LIT(KCmdCancelRead, "CancelRead"); +_LIT(KCmdCancelRecv, "CancelRecv"); +_LIT(KCmdCancelSend, "CancelSend"); +_LIT(KCmdCancelWrite, "CancelWrite"); +_LIT(KCmdConnect, "Connect"); +_LIT(KCmdDestructor, "~"); +_LIT(KCmdGetDisconnectData, "GetDisconnectData"); +_LIT(KCmdGetOpt, "GetOpt"); +_LIT(KCmdInfo, "Info"); +_LIT(KCmdIoctl, "Ioctl"); +_LIT(KCmdListen, "Listen"); +_LIT(KCmdLocalName, "LocalName"); +_LIT(KCmdLocalPort, "LocalPort"); +_LIT(KCmdName, "Name"); +_LIT(KCmdNewL, "NewL"); +_LIT(KCmdNewLC, "NewLC"); +_LIT(KCmdPhysicalLinkState, "PhysicalLinkState"); +_LIT(KCmdPreventLowPowerModes, "PreventLowPowerModes"); +_LIT(KCmdPreventRoleSwitch, "PreventRoleSwitch"); +_LIT(KCmdRConnectionClose, "RConnectionClose"); +_LIT(KCmdRConnectionStart, "RConnectionStart"); +_LIT(KCmdRead, "Read"); +_LIT(KCmdRecv, "Recv"); +_LIT(KCmdRecvFrom, "RecvFrom"); +_LIT(KCmdRecvOneOrMore, "RecvOneOrMore"); +_LIT(KCmdRemoteName, "RemoteName"); +_LIT(KCmdRequestChangeSupportedPacketTypes, "RequestChangeSupportedPacketTypes"); +_LIT(KCmdRequestMasterRole, "RequestMasterRole"); +_LIT(KCmdRequestSlaveRole, "RequestSlaveRole"); +_LIT(KCmdRSocketServerClose, "RSocketServerClose"); +_LIT(KCmdRSocketServerConnect, "RSocketServerConnect"); +_LIT(KCmdSend, "Send"); +_LIT(KCmdSendTo, "SendTo"); +_LIT(KCmdSetAutomaticSniffMode, "SetAutomaticSniffMode"); +_LIT(KCmdSetLocalPort, "SetLocalPort"); +_LIT(KCmdSetOpt, "SetOpt"); +_LIT(KCmdSetOption, "SetOption"); +_LIT(KCmdSetRsocketServerFromCBTSocket, "SetRsocketServerFromCBTSocket"); +_LIT(KCmdSetTransferAble, "SetTransferAble"); +_LIT(KCmdShutdown, "Shutdown"); +_LIT(KCmdSetNotifier, "SetNotifier"); +_LIT(KCmdTestMBSN_ExtensionInterfaceL, "TestMBSN_ExtensionInterfaceL"); +_LIT(KCmdTransfer, "Transfer"); +_LIT(KCmdWrite, "Write"); + +/// Other +_LIT_SECURITY_POLICY_C2(KProcPolicy, ECapabilityNetworkServices, ECapabilityNetworkControl); +/*@}*/ + +CT_CBluetoothSocketData* CT_CBluetoothSocketData::NewL() + { + CT_CBluetoothSocketData* ret=new (ELeave) CT_CBluetoothSocketData(); + CleanupStack::PushL(ret); + ret->ConstructL(); + CleanupStack::Pop(ret); + return ret; + } + +/** +* First phase construction +*/ +CT_CBluetoothSocketData::CT_CBluetoothSocketData() +: iData(NULL) +, iHasConnectDataToExpect(EFalse) +, iHasAcceptDataToExpect(EFalse) +, iHasReceiveDataToExpect(EFalse) +, iConnectIndex(0) +, iAcceptIndex(0) +, iShutdownIndex(0) +, iIoctlIndex(0) +, iNotifierIndex(0) +, iReceiveIndex(0) +, iSendIndex(0) + { + } + +/** +* Second phase construction +*/ +void CT_CBluetoothSocketData::ConstructL() + { + iData=new (ELeave) CT_BluetoothSocketNotifier(); + iData->SetServer(this); + } + +CT_CBluetoothSocketData::~CT_CBluetoothSocketData() + { + } + +// Service methods +TAny* CT_CBluetoothSocketData::GetObject() + { + return iData; + } + +void CT_CBluetoothSocketData::SetObjectL(TAny* aObject) + { + //called when loading up persistent data + delete iData; + iData = static_cast(aObject); + iData->SetServer(this); + } + +void CT_CBluetoothSocketData::DisownObjectL() + { + if ( iData ) + { + iData->SetServer(NULL); + iData=NULL; + } + } + +inline TCleanupOperation CT_CBluetoothSocketData::CleanupOperation() + { + return CleanupOperation; + } + +void CT_CBluetoothSocketData::CleanupOperation(TAny* aAny) + { + //may be unnecessary + CT_BluetoothSocketNotifier* arg=static_cast(aAny); + delete arg; + } + +TBool CT_CBluetoothSocketData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex) + { + TBool retVal=ETrue; + + //------------------------------------------------------------------------- + // CBluetoothSocket + //------------------------------------------------------------------------- + if (aCommand==KCmdRSocketServerConnect) + { + DoCmdCloseSocketServer(); + User::LeaveIfError(iData->iSocketServer.Connect()); + iData->iSocketServerConnected=ETrue; + } + else if (aCommand==KCmdRSocketServerClose) + { + DoCmdCloseSocketServer(); + } + else if (aCommand==KCmdRConnectionStart) + { + TInt err = iData->iConnection.Open(iData->iSocketServer, KBTAddrFamily); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("RConnection::Open() err=%d" ),err); + SetError(err); + } + + err = iData->iConnection.Start(); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("RConnection::Start() err=%d" ),err); + SetError(219); + } + } + else if (aCommand==KCmdRConnectionClose) + { + iData->iConnection.Close(); + } + else if (aCommand==KCmdDestructor) + { + delete iData->iBluetoothSocket; + iData->iBluetoothSocket=NULL; + } + else if ( aCommand==KCmdNewL ) + { + DoCmdNewL(aSection,EFalse); + } + else if ( aCommand==KCmdNewLC ) + { + DoCmdNewL(aSection,ETrue); + } + else if ( aCommand==KCmdBind) + { + DoCmdBind(aSection); + } + else if ( aCommand==KCmdListen) + { + DoCmdListen(aSection); + } + else if ( aCommand==KCmdLocalName) + { + DoCmdLocalName(aSection); + } + else if ( aCommand==KCmdLocalPort) + { + DoCmdLocalPort(aSection); + } + else if ( aCommand==KCmdSetLocalPort) + { + DoCmdSetLocalPort(aSection); + } + else if ( aCommand==KCmdSetOpt) + { + DoCmdSetOpt(aSection); + } + else if ( aCommand==KCmdSetOption) + { + DoCmdSetOption(aSection); + } + else if ( aCommand==KCmdGetOpt) + { + DoCmdGetOpt(aSection); + } + else if ( aCommand==KCmdName) + { + DoCmdName(); + } + else if ( aCommand==KCmdSetTransferAble) + { + DoCmdSetTransferAble(); + } + else if ( aCommand==KCmdTransfer) + { + DoCmdTransfer(aSection); + } + else if ( aCommand==KCmdInfo) + { + DoCmdInfo(aSection); + } + else if ( aCommand==KCmdAccept) + { + DoCmdAccept(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdCancelAccept) + { + DoCmdCancelAccept(); + } + else if ( aCommand==KCmdConnect) + { + DoCmdConnect(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdSend) + { + DoCmdSend(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdRecv) + { + DoCmdRecv(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdRecvOneOrMore) + { + DoCmdRecvOneOrMore(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdShutdown) + { + DoCmdShutdown(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdSetNotifier) + { + DoCmdSetNotifierL(aSection); + } + else if ( aCommand==KCmdCancelConnect) + { + DoCmdCancelConnect(); + } + else if ( aCommand==KCmdSetRsocketServerFromCBTSocket) + { + DoCmdSetRsocketServerFromCBTSocket(aSection); + } + else if ( aCommand==KCmdIoctl) + { + DoCmdIoctl(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdCancelIoctl) + { + DoCmdCancelIoctl(); + } + else if ( aCommand==KCmdAllowLowPowerModes) + { + DoCmdAllowLowPowerModes(aSection); + } + else if ( aCommand==KCmdCancelLowPowerModeRequester) + { + DoCmdCancelLowPowerModeRequester(aSection); + } + else if ( aCommand==KCmdPreventLowPowerModes) + { + DoCmdPreventLowPowerModes(aSection); + } + else if ( aCommand==KCmdActivateBasebandEventNotifier) + { + DoCmdActivateBasebandEventNotifier(aSection, aAsyncErrorIndex); + } + else if ( aCommand==KCmdCancelBasebandEventNotifier) + { + DoCmdCancelBasebandEventNotifier(); + } + else if ( aCommand==KCmdPhysicalLinkState) + { + DoCmdPhysicalLinkState(aSection); + } + else if ( aCommand==KCmdPreventRoleSwitch) + { + DoCmdPreventRoleSwitch(); + } + else if ( aCommand==KCmdAllowRoleSwitch) + { + DoCmdAllowRoleSwitch(); + } + else if ( aCommand==KCmdRequestMasterRole) + { + DoCmdRequestMasterRole(); + } + else if ( aCommand==KCmdRequestSlaveRole) + { + DoCmdRequestSlaveRole(); + } + else if ( aCommand==KCmdActivateSniffRequester) + { + DoCmdActivateSniffRequester(); + } + else if ( aCommand==KCmdActivateParkRequester) + { + DoCmdActivateParkRequester(); + } + else if ( aCommand==KCmdCancelSend) + { + DoCmdCancelSend(); + } + else if ( aCommand==KCmdCancelAll) + { + DoCmdCancelAll(); + } + else if ( aCommand==KCmdWrite) + { + DoCmdWrite(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdCancelWrite) + { + DoCmdCancelWrite(); + } + else if ( aCommand==KCmdSendTo) + { + DoCmdSendTo(aSection, aAsyncErrorIndex); + } + else if ( aCommand==KCmdRecvFrom) + { + DoCmdRecvFrom(aSection,aAsyncErrorIndex); + } + else if ( aCommand==KCmdGetDisconnectData) + { + DoCmdGetDisconnectData(); + } + else if ( aCommand==KCmdRequestChangeSupportedPacketTypes) + { + DoCmdRequestChangeSupportedPacketTypes(aSection); + } + else if ( aCommand==KCmdCancelRecv) + { + DoCmdCancelRecv(); + } + else if ( aCommand==KCmdRead) + { + DoCmdRead(aSection, aAsyncErrorIndex); + } + else if ( aCommand==KCmdCancelRead) + { + DoCmdCancelRead(); + } + else if ( aCommand==KCmdRemoteName) + { + DoCmdRemoteName(aSection); + } + else if ( aCommand==KCmdTestMBSN_ExtensionInterfaceL) + { + DoCmdTestMBSN_ExtensionInterfaceL(aSection); + } + else if ( aCommand==KCmdSetAutomaticSniffMode) + { + DoCmdSetAutomaticSniffMode(aSection); + } + else + { + retVal=EFalse; + } + return retVal; + } + + +inline void CT_CBluetoothSocketData::DoCmdAccept(const TDesC& aSection, const TInt aAsyncErrorIndex) + { + + TPtrC expectedReply; + iAcceptFlag = EFalse; + iHasAcceptDataToExpect=GetStringFromConfig(aSection, KExpectedReply(), expectedReply); + if ( iHasAcceptDataToExpect ) + { + iAcceptDataToExpect.Copy(expectedReply); + } + + TBool useAccept2 =EFalse; + GetBoolFromConfig(aSection, KUseAccept2(), useAccept2); + + // Get the blank session socket + TPtrC bluetoothSocketName; + CBluetoothSocket* bluetoothSocket=NULL; + if( GetStringFromConfig(aSection, KCBluetoothSocket(), bluetoothSocketName)) + { + bluetoothSocket=(static_cast(GetDataObjectL(bluetoothSocketName))->iBluetoothSocket); + if ( bluetoothSocket!=NULL ) + { + TInt status; + if ( useAccept2 ) + { + INFO_PRINTF1(_L("Using Accept 2")); + status = iData->iBluetoothSocket->Accept(*bluetoothSocket, iDataToRead8); + } + else + { + INFO_PRINTF1(_L("Using Accept 1")); + status = iData->iBluetoothSocket->Accept(*bluetoothSocket); + } + + if(status==KErrNone) + { + IncOutstanding(); + iAcceptFlag = ETrue; + iAcceptIndex = aAsyncErrorIndex; + } + else + { + ERR_PRINTF2(_L("Accept failed: %d"),status); + SetError(status); + } + } + else + { + ERR_PRINTF1(_L("Bind TSockAddr is NULL")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdActivateBasebandEventNotifier(const TDesC& aSection,const TInt aAsyncErrorIndex) + { + // loop through all values in the ini file and add them up + TUint32 flags=0; + CT_BTUtil::GetLinkStateNotifierBits(*this, aSection, flags); + + TInt errCode = iData->iBluetoothSocket->ActivateBasebandEventNotifier(flags); + if ( errCode==KErrNone ) + { + IncOutstanding(); + iNotifierIndex = aAsyncErrorIndex; + } + else + { + ERR_PRINTF2(_L("ActivateBasebandEventNotifier failed with error code: %d"), errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdActivateParkRequester() + { + TInt errCode = iData->iBluetoothSocket->ActivateParkRequester(); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("ActivateParkRequester failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdActivateSniffRequester() + { + TInt errCode = iData->iBluetoothSocket->ActivateSniffRequester(); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("ActivateSniffRequester failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdAllowLowPowerModes(const TDesC& aSection) + { + TUint32 mode=0; + CT_BTUtil::GetLowPowerMode(*this, aSection, mode); + + TInt errCode=iData->iBluetoothSocket->AllowLowPowerModes(mode); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Send AllowLowPowerModes failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdAllowRoleSwitch() + { + TInt errCode = iData->iBluetoothSocket->AllowRoleSwitch(); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("AllowRoleSwitch failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdBind(const TDesC& aSection) + { + TPtrC sockAddrName; + if( GetStringFromConfig(aSection, KTSockAddr(), sockAddrName)) + { + INFO_PRINTF2(_L("Binding with: %S TSockAddr"), &sockAddrName); + TBTSockAddr* sockAddr=static_cast(GetDataObjectL(sockAddrName)); + if ( sockAddr!=NULL ) + { + TInt errCode = iData->iBluetoothSocket->Bind(*sockAddr); + if(errCode!=KErrNone) + { + ERR_PRINTF2(_L("Bind failed: %d"), errCode); + SetError(errCode); + } + } + else + { + ERR_PRINTF1(_L("Bind TSockAddr is NULL")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelAccept() + { + iData->iBluetoothSocket->CancelAccept(); + if(Outstanding() && iAcceptFlag) + { + DecOutstanding(); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelAll() + { + iData->iBluetoothSocket->CancelAll(); + } + +inline void CT_CBluetoothSocketData::DoCmdCancelBasebandEventNotifier() + { + iData->iBluetoothSocket->CancelBasebandEventNotifier(); + if(Outstanding() && iNotifierFlag) + { + DecOutstanding(); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelConnect() + { + iData->iBluetoothSocket->CancelConnect(); + if(Outstanding() && iConnectFlag) + { + DecOutstanding(); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelIoctl() + { + iData->iBluetoothSocket->CancelIoctl(); + if(Outstanding() && iIoctlFlag) + { + DecOutstanding(); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelLowPowerModeRequester(const TDesC& /*aSection*/) + { + TInt errCode=iData->iBluetoothSocket->CancelLowPowerModeRequester(); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Send CancelLowPowerModeRequester failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelRead() + { + iData->iBluetoothSocket->CancelRead(); + if (Outstanding() && iReadFlag) + { + DecOutstanding(); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelRecv() + { + iData->iBluetoothSocket->CancelRecv(); + if (Outstanding() && iRecvFlag) + { + DecOutstanding(); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelSend() + { + iData->iBluetoothSocket->CancelSend(); + if (Outstanding() && iSendFlag) + { + DecOutstanding(); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCancelWrite() + { + iData->iBluetoothSocket->CancelWrite(); + if (Outstanding() && iWriteFlag) + { + DecOutstanding(); + } + } + +inline void CT_CBluetoothSocketData::DoCmdCloseSocketServer() + { + if(iData->iSocketServerConnected) + { + iData->iSocketServer.Close(); + } + iData->iSocketServerConnected=EFalse; + } + +inline void CT_CBluetoothSocketData::DoCmdConnect(const TDesC& aSection, const TInt aAsyncErrorIndex) + { + + TPtrC expectedReply; + iConnectFlag = EFalse; + iHasConnectDataToExpect=GetStringFromConfig(aSection, KExpectedReply(), expectedReply); + if ( iHasConnectDataToExpect ) + { + iConnectDataToExpect.Copy(expectedReply); + } + + TPtrC sockAddrName; + if( GetStringFromConfig(aSection, KTBTSockAddr(), sockAddrName)) + { + INFO_PRINTF2(_L("Connecting with: %S TBTSockAddr"), &sockAddrName); + TBTSockAddr* myTBTSockAddr=static_cast(GetDataObjectL(sockAddrName)); + if ( myTBTSockAddr!=NULL ) + { + TInt errCode=KErrNone; + + TInt serviceBits; + if ( GetIntFromConfig(aSection, KServiceBits(), serviceBits) ) + { + INFO_PRINTF1(_L("Using Connect 3")); + + TBTDevAddr tempAddress = myTBTSockAddr->BTAddr(); + TBuf tmpBuf; + tempAddress.GetReadable(tmpBuf); + INFO_PRINTF2(_L("Connecting to address (%S)"), &tmpBuf); + + errCode=iData->iBluetoothSocket->Connect(*myTBTSockAddr, serviceBits); + } + else + { + TPtrC connectData; + if ( GetStringFromConfig(aSection, KConnectData(), connectData) ) + { + INFO_PRINTF1(_L("Using Connect 2")); + TBuf8 connectData8(_L8("")); + connectData8.Copy(connectData); + + TBTDevAddr tempAddress = myTBTSockAddr->BTAddr(); + TBuf tmpBuf; + tempAddress.GetReadable(tmpBuf); + INFO_PRINTF2(_L("Connecting to address (%S)"), &tmpBuf); + + errCode =iData->iBluetoothSocket->Connect(*myTBTSockAddr, iDataToRead8, connectData8); + } + else + { + INFO_PRINTF1(_L("Using Connect 1")); + + TBTDevAddr tempAddress = myTBTSockAddr->BTAddr(); + TBuf tmpBuf; + tempAddress.GetReadable(tmpBuf); + INFO_PRINTF2(_L("Connecting to address (%S)"), &tmpBuf); + + errCode =iData->iBluetoothSocket->Connect(*myTBTSockAddr); + } + } + if ( errCode == KErrNone) + { + IncOutstanding(); + iConnectFlag = ETrue; + iConnectIndex = aAsyncErrorIndex; + } + else + { + ERR_PRINTF2(_L("Connect failed: %d"), errCode); + SetError(errCode); + } + } + else + { + ERR_PRINTF1(_L("Connect TBTSockAddr is NULL")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdGetDisconnectData() + { + TInt errCode = iData->iBluetoothSocket->GetDisconnectData(iDisconnectDes8); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("GetDisconnectData failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdGetOpt(const TDesC& aSection) + { + TBool found; + + TBool equals = ETrue; + GetBoolFromConfig(aSection, KEquals(), equals); + if (equals) + { + INFO_PRINTF1(_L("The comparison is expected to be equal.")); + } + else + { + INFO_PRINTF1(_L("The comparison is not expected to be equal.")); + } + + TBool dataOk=ETrue; + TPtrC optionName; + TInt optionNameValue=0; + if ( GetStringFromConfig(aSection, KOptionName(), optionName) ) + { + dataOk=CT_BTUtil::GetIntValue(optionName, optionNameValue); + + //Report error but continue as it may still make sense + if (dataOk) + { + INFO_PRINTF3(_L("The name of the option to set: %S , its value: %d" ), &optionName, optionNameValue); + } + else + { + ERR_PRINTF2(_L("Option Level not found in lookup: %S"),&optionName); + SetBlockResult(EFail); + } + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Data %S missing"), &KOptionName()); + SetBlockResult(EFail); + } + + TPtrC optionLevel; + TInt optionLevelValue; + if( GetStringFromConfig(aSection, KOptionLevel(), optionLevel)) + { + found=CT_BTUtil::GetIntValue(optionLevel, optionLevelValue); + //Report error but continue as it may still make sense + if (found) + { + INFO_PRINTF3(_L("The name of the option level to set: %S , its value: %d" ),&optionLevel, optionLevelValue); + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Option Level not found in lookup: %S"),&optionLevel); + SetBlockResult(EFail); + } + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Data %S missing"), &KOptionLevel()); + SetBlockResult(EFail); + } + + if ( dataOk ) + { + TBool getDes=EFalse; + GetBoolFromConfig(aSection, KGetDes(), getDes); + + if ( getDes ) + { + TBuf8 tempData8(_L8("")); + TInt err = iData->iBluetoothSocket->GetOpt(optionNameValue, optionLevelValue, tempData8); + if( err != KErrNone ) + { + INFO_PRINTF2(_L("GetOpt() return error %d" ), err); + SetError(err); + } + + TBuf tempData; + tempData.Copy(tempData8); + INFO_PRINTF3(_L("The value of the option retrived as des: %S, descriptor length: %d" ), &tempData, tempData.Length()); + + TPtrC desOption; // descriptor to compare with if getdes is TRUE + if( GetStringFromConfig(aSection, KDesOption(), desOption)) + { + INFO_PRINTF2(_L("The expected descriptor value: %S" ), &desOption); + if ( (desOption==tempData) == equals ) + { + INFO_PRINTF1(_L("Option is as expected")); + } + else + { + ERR_PRINTF1(_L("Option is not as expected")); + SetBlockResult(EFail); + } + } + } + else + { + TInt val; + TInt err = iData->iBluetoothSocket->GetOpt(optionNameValue, optionLevelValue, val); + if( err != KErrNone ) + { + INFO_PRINTF2(_L("GetOpt() return error %d" ), err); + SetError(err); + } + + INFO_PRINTF2(_L("The value of the option retrived: %d" ),val); + + TInt intOption; // int value to compare with if getdes is FALSE or not defined + if( GetIntFromConfig(aSection, KIntOption(), intOption)) + { + INFO_PRINTF1(_L("Comparing results")); + if ( (intOption==val) == equals ) + { + INFO_PRINTF1(_L("Option is as expected")); + } + else + { + ERR_PRINTF1(_L("Option is not as expected")); + SetBlockResult(EFail); + } + } + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdInfo(const TDesC& aSection) + { + TProtocolDesc protocolDesc; + TInt err = iData->iBluetoothSocket->Info(protocolDesc); + + if ( err!=KErrNone ) + { + ERR_PRINTF2(_L("iBluetoothSocket->Info error: %d"), err); + SetError(err); + } + + INFO_PRINTF2(_L("iBluetoothSocket->Info() = %S"), &protocolDesc.iName); + + TPtrC expectedValue; + if( GetStringFromConfig(aSection, KExpectedReply(), expectedValue) ) + { + if( expectedValue != protocolDesc.iName ) + { + ERR_PRINTF3(_L("Expected Info (%S) != Actual Info (%S)"), &expectedValue, &protocolDesc.iName); + SetBlockResult(EFail); + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdIoctl(const TDesC& aSection,const TInt aAsyncErrorIndex) + { + TBool dataOk = ETrue; + iIoctlFlag = EFalse; + TBool boolCallTwice = EFalse; + GetBoolFromConfig(aSection, KCallTwice(), boolCallTwice); + + TBool useDeprecated=EFalse; + GetBoolFromConfig(aSection, KUseDeprecated(), useDeprecated); + + TBool found = EFalse; + + TPtrC optionName; + TInt optionNameValue=0; + if( GetStringFromConfig(aSection, KOptionName(), optionName)) + { + found=CT_BTUtil::GetIntValue(optionName, optionNameValue); + //Report error but continue as it may still make sense + if (found) + { + INFO_PRINTF3(_L("The name of the option to set: %S , its value: %d" ), &optionName, optionNameValue); + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Option not found in lookup: %S"), &optionName); + SetBlockResult(EFail); + } + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Missing: %S"), &KOptionName()); + SetBlockResult(EFail); + } + + TPtrC optionLevel; + TInt optionLevelValue; + if( GetStringFromConfig(aSection, KOptionLevel(), optionLevel)) + { + found=CT_BTUtil::GetIntValue(optionLevel, optionLevelValue); + //Report error but continue as it may still make sense + if (found) + { + INFO_PRINTF3(_L("The name of the option level to set: %S , its value: %d" ), &optionLevel, optionLevelValue); + } + else + { + ERR_PRINTF2(_L("Option Level not found in lookup: %S"), &optionLevel); + SetBlockResult(EFail); + } + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Missing: %S"), &KOptionLevel()); + SetBlockResult(EFail); + } + + if ( dataOk ) + { + TInt mtuOptionBufferSize = 0; + GetIntFromConfig(aSection, KMTUSize(), mtuOptionBufferSize); + + if( mtuOptionBufferSize > DATASIZE ) + { + mtuOptionBufferSize = DATASIZE; + WARN_PRINTF3(_L("mtuOptionBufferSize %d is large, using %d"), mtuOptionBufferSize, DATASIZE); + } + + iMTUOptionBuffer = TPckgBuf(mtuOptionBufferSize); + + TInt errCode=KErrNone; + if (useDeprecated) + { + errCode=iData->iBluetoothSocket->Ioctl(optionNameValue, &iMTUOptionBuffer, optionLevelValue); + } + else + { + errCode=iData->iBluetoothSocket->Ioctl(optionLevelValue, optionNameValue, &iMTUOptionBuffer); + } + + if (errCode == KErrNone) + { + IncOutstanding(); + iIoctlFlag = ETrue; + iIoctlIndex = aAsyncErrorIndex; + } + else + { + ERR_PRINTF2(_L("Send Ioctl failed with error code: %d"), errCode); + SetError(errCode); + } + + if( boolCallTwice ) + { + if (useDeprecated) + { + errCode=iData->iBluetoothSocket->Ioctl(optionNameValue, &iMTUOptionBuffer, optionLevelValue); + } + else + { + errCode=iData->iBluetoothSocket->Ioctl(optionLevelValue, optionNameValue, &iMTUOptionBuffer); + } + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Send Ioctl failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iIoctlFlag = ETrue; + //NB! May be not necessary, because the second call must call panics + iIoctlIndex = aAsyncErrorIndex; + } + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdListen(const TDesC& aSection) + { + + TInt queueSize; + if ( GetIntFromConfig(aSection, KQueueSize(), queueSize) ) + { + TInt errCode=KErrNone; + + TPtrC connectData; + if ( GetStringFromConfig(aSection, KConnectData(), connectData) ) + { + iConnectData8 = _L8(""); + iConnectData8.Copy(connectData); + errCode=iData->iBluetoothSocket->Listen(queueSize, iConnectData8); + } + else + { + TInt serviceBits; + if ( GetIntFromConfig(aSection, KServiceBits(), serviceBits) ) + { + INFO_PRINTF2(_L("Using Listen 3 Service bits is: %d"),serviceBits); + errCode=iData->iBluetoothSocket->Listen(queueSize, serviceBits); + } + else + { + INFO_PRINTF1(_L("Using Listen 1")); + errCode=iData->iBluetoothSocket->Listen(queueSize); + } + } + if ( errCode!=KErrNone ) + { + ERR_PRINTF2(_L("Listen failed: %d"),errCode); + SetError(errCode); + } + } + else + { + ERR_PRINTF2(_L("Missing: %Sfailed"), &KServiceBits()); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdLocalName(const TDesC& aSection) + { + + T_TBTSockAddrChild addr; + iData->iBluetoothSocket->LocalName(addr); + + TBTDevAddr currentAddr = addr.BTAddr(); + TBuf tmpBuf; + currentAddr.GetReadable(tmpBuf); + INFO_PRINTF2(_L("LocalName() = 0x%S"), &tmpBuf); + TPtrC myTBTDevAddrName; + if ( GetStringFromConfig(aSection, KTBTDevAddr(), myTBTDevAddrName) ) + { + CT_BTDevAddrData* myTBTDevAddrData=static_cast(GetDataWrapperL(myTBTDevAddrName)); + TBTDevAddr btDevAddr = *myTBTDevAddrData->GetAddress(); + TBuf tmpBuf2; + btDevAddr.GetReadable(tmpBuf2); + if (tmpBuf2 != tmpBuf) + { + ERR_PRINTF3(_L("Expected address (%S) != actual address (%S)"),&tmpBuf2,&tmpBuf); + SetBlockResult(EFail); + } + } + else + { + TInt lhs; + TInt rhs; + TBool lhsGiven = EFalse; + TBool rhsGiven = EFalse; + lhsGiven = GetHexFromConfig(aSection, KHexBTAddrL(), lhs ); + rhsGiven = GetHexFromConfig(aSection, KHexBTAddrR(), rhs ); + + if (lhsGiven && rhsGiven) + { + TBTDevAddr btDevAddr (MAKE_TINT64(lhs, rhs)); + TBuf tmpBuf2; + btDevAddr.GetReadable(tmpBuf2); + if (tmpBuf2 != tmpBuf) + { + ERR_PRINTF3(_L("Expected address (%S) != actual address (%S)"),&tmpBuf2,&tmpBuf); + SetBlockResult(EFail); + } + } + } + + // Set in TBTSockAddr Data object so that it can be verified + TPtrC myTSockAddrName; + CT_BTSockAddrData* myTSockAddrData=NULL; + if( GetStringFromConfig(aSection, KTSockAddr(), myTSockAddrName)) + { + myTSockAddrData=static_cast(GetDataWrapperL(myTSockAddrName)); + if ( myTSockAddrData!=NULL ) + { + myTSockAddrData->SetObject(&addr,EFalse); + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdLocalPort(const TDesC& aSection) + { + + TInt actualPort = iData->iBluetoothSocket->LocalPort(); + INFO_PRINTF2(_L("Actual port is: %d"), actualPort); + + TInt port; + if ( GetIntFromConfig(aSection, KPort(), port) ) + { + INFO_PRINTF2(_L("Expected port is: %d"), port); + if ( actualPort!=port ) + { + ERR_PRINTF1(_L("LocalPort is not as expected")); + SetBlockResult(EFail); + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdName() + { + TName theName; + TInt err=iData->iBluetoothSocket->Name(theName); + if ( err==KErrNone ) + { + // good print the name + INFO_PRINTF2(_L("The socket name is: (%S)" ), &theName); + } + else + { + ERR_PRINTF2(_L("Failed to get the Name of the Bluetoothsocket, error code %d returned"),err); + SetError(err); + } + } + +inline void CT_CBluetoothSocketData::DoCmdNewL(const TDesC& aSection, TBool aUseLC) + { + + TInt constructorType = 0; + GetIntFromConfig(aSection, KConstructorType(), constructorType); + + if ((constructorType >0 )&&(constructorType < 6)) + { + TBool dataOk=ETrue; + TBool found = EFalse; + + delete iData->iBluetoothSocket; + iData->iBluetoothSocket = NULL; + + if( constructorType == 1 ) + { + INFO_PRINTF1(_L("CBluetoothSocket Standard Constructor Call")); + + TInt intSockType=0; + TPtrC sockType; + if( GetStringFromConfig(aSection, KSockType(), sockType) ) + { + found=CT_BTUtil::GetIntValue(sockType, intSockType); + if ( !found ) + { + dataOk=EFalse; + ERR_PRINTF2(_L("Socket type not found in lookup: %S"),&sockType); + SetBlockResult(EFail); + } + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Missing :%S"), &KSockType()); + SetBlockResult(EFail); + } + + TInt intProtocol; + TPtrC protocol; + if ( GetStringFromConfig(aSection, KProtocol(), protocol) ) + { + found=CT_BTUtil::GetIntValue(protocol, intProtocol); + if ( !found ) + { + dataOk=EFalse; + ERR_PRINTF2(_L("Socket type not found in lookup: %S"),&sockType); + SetBlockResult(EFail); + } + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Missing :%S"), &KProtocol()); + SetBlockResult(EFail); + } + + if ( dataOk ) + { + if(aUseLC) + { + INFO_PRINTF1(_L("CBluetoothSocket Standard Constructor NewLC" )); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewLC(*iData, iData->iSocketServer, intSockType, intProtocol); CleanupStack::Pop();); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket Standard Constructor NewLC err=%d" ),err); + SetError(err); + } + } + else + { + INFO_PRINTF1(_L("CBluetoothSocket Standard Constructor NewL" )); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewL(*iData, iData->iSocketServer, intSockType, intProtocol)); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket Standard Constructor NewL err=%d" ),err); + SetError(err); + } + } + } + } + else if( constructorType == 2 ) + { + INFO_PRINTF1(_L("CBluetoothSocket RConnection Constructor Call")); + + TInt theSockType=0; + TPtrC sockType; + if ( GetStringFromConfig(aSection, KSockType(), sockType) ) + { + found=CT_BTUtil::GetIntValue(sockType, theSockType); + if ( !found ) + { + dataOk=EFalse; + ERR_PRINTF2(_L("Socket type not found in lookup: %S"), &sockType); + SetBlockResult(EFail); + } + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Missing :%S"), &KSockType()); + SetBlockResult(EFail); + } + + TInt theProtocol; + TPtrC protocol; + if ( GetStringFromConfig(aSection, KProtocol(), protocol) ) + { + found=CT_BTUtil::GetIntValue(protocol, theProtocol); + if (!found) + { + dataOk=EFalse; + ERR_PRINTF2(_L("Protocol not found in lookup: %S"), &protocol); + SetBlockResult(EFail); + } + } + else + { + dataOk=EFalse; + ERR_PRINTF2(_L("Missing :%S"), &KProtocol()); + SetBlockResult(EFail); + } + + if ( dataOk ) + { + if ( aUseLC ) + { + INFO_PRINTF1(_L("CBluetoothSocket RConnection Constructor NewLC" )); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewLC(*iData, iData->iSocketServer, theSockType, theProtocol, iData->iConnection); CleanupStack::Pop();); + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket RConnection Constructor NewLC err=%d" ),err); + SetError(err); + } + } + else + { + INFO_PRINTF1(_L("CBluetoothSocket RConnection Constructor NewL" )); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewL(*iData, iData->iSocketServer, theSockType, theProtocol,iData->iConnection)); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket RConnection Constructor NewL err=%d" ),err); + SetError(err); + } + } + } + } + else if( constructorType == 3 ) + { + INFO_PRINTF1(_L("CBluetoothSocket Named Protocol Constructor Call")); + + TPtrC namedProtocol; + if( GetStringFromConfig(aSection, KNamedProtocol(), namedProtocol)) + { + if (aUseLC) + { + INFO_PRINTF1(_L("CBluetoothSocket Named Protocol Constructor NewLC" )); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewLC(*iData, iData->iSocketServer, namedProtocol); CleanupStack::Pop();); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket Named Protocol Constructor NewLC err=%d" ),err); + SetError(err); + } + } + + else + { + INFO_PRINTF1(_L("CBluetoothSocket Named Protocol Constructor NewL" )); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewL(*iData, iData->iSocketServer, namedProtocol)); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket Named Protocol Constructor NewL err=%d" ),err); + SetError(err); + } + } + } + else + { + ERR_PRINTF2(_L("Missing :%s"), &KNamedProtocol()); + SetBlockResult(EFail); + } + } + else if( constructorType == 4 ) + { + if (aUseLC) + { + INFO_PRINTF1(_L("CBluetoothSocket Blank Constructor NewLC")); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewLC(*iData, iData->iSocketServer); CleanupStack::Pop();); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket Blank Constructor NewLC err=%d" ),err); + SetError(err); + } + } + else + { + INFO_PRINTF1(_L("CBluetoothSocket Blank Constructor NewL")); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewL(*iData, iData->iSocketServer)); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket Blank Constructor NewL err=%d" ),err); + SetError(err); + } + } + } + else if( constructorType == 5 ) + { + INFO_PRINTF1(_L("CBluetoothSocket RSocket Constructor Call")); + + TPtrC myRSocketName; + if( GetStringFromConfig(aSection, KRSocket(), myRSocketName)) + { + RSocket* myRSocket=static_cast(GetDataObjectL(myRSocketName)); + if ( myRSocket!=NULL ) + { + if (aUseLC) + { + INFO_PRINTF1(_L("CBluetoothSocket RSocket Constructor NewLC" )); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewLC(*iData, iData->iSocketServer, *myRSocket); CleanupStack::Pop();); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket RSocket Constructor NewLC err=%d" ),err); + SetError(err); + } + } + else + { + INFO_PRINTF1(_L("CBluetoothSocket RSocket Constructor NewL" )); + TRAPD(err, iData->iBluetoothSocket = CBluetoothSocket::NewL(*iData, iData->iSocketServer, *myRSocket)); + + if( err!=KErrNone ) + { + INFO_PRINTF2(_L("CBluetoothSocket RSocket Constructor NewL err=%d" ),err); + SetError(err); + } + } + } + else + { + ERR_PRINTF2(_L("Failed to fetch RSocket named %S"),&myRSocketName); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF2(_L("Missing :%S"), &KRSocket()); + SetBlockResult(EFail); + } + } + else + { + INFO_PRINTF2(_L("Incorrect constructorType = %d" ),constructorType); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF2(_L("Ilegal value for constructor type value in range 1-5 expected found: %d"),constructorType); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdPhysicalLinkState(const TDesC& aSection) + { + + TUint32 tmpstate; + TInt errCode = iData->iBluetoothSocket->PhysicalLinkState(tmpstate); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("PhysicalLinkState failed with error code: %d"),errCode); + SetError(errCode); + } + + TInt state = static_cast(tmpstate); + //Process the state we can do a nice report here as we know what the bits are + // See CT_BTUtil as a starting point + INFO_PRINTF2(_L("PhysicalLinkState: %d" ), state ); + + TInt expectedState; + if( GetIntFromConfig(aSection, KState(), expectedState) ) + { + if( expectedState != state ) + { + ERR_PRINTF3(_L("Expected PhysicalLinkState (%d) != Actual PhysicalLinkState (%d)"), state, expectedState); + SetBlockResult(EFail); + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdPreventLowPowerModes(const TDesC& aSection) + { + TUint32 mode =0; + CT_BTUtil::GetLowPowerMode(*this, aSection, mode); + + TInt errCode=iData->iBluetoothSocket->PreventLowPowerModes(mode); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Send PreventLowPowerModes failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdPreventRoleSwitch() + { + TInt errCode = iData->iBluetoothSocket->PreventRoleSwitch(); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("PreventRoleSwitch failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdRead(const TDesC& aSection, const TInt aAsyncErrorIndex) + { + + TPtrC expectedReply; + iReadFlag = EFalse; + iHasReceiveDataToExpect=GetStringFromConfig(aSection, KExpectedReply(), expectedReply); + if ( iHasReceiveDataToExpect ) + { + iReceiveDataToExpect.Copy(expectedReply); + } + + TBool boolCallTwice = EFalse; + GetBoolFromConfig(aSection, KCallTwice(), boolCallTwice); + + TInt errCode = iData->iBluetoothSocket->Read(iDataToRead8); + if (errCode == KErrNone) + { + IncOutstanding(); + iReadFlag = ETrue; + iReceiveIndex = aAsyncErrorIndex; + } + else + { + ERR_PRINTF2(_L("Read failed with error code: %d"),errCode); + SetError(errCode); + } + + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->Read(iDataToRead8); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Read failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iReadFlag = ETrue; + iReceiveIndex = aAsyncErrorIndex; + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdRecv(const TDesC& aSection, const TInt aAsyncErrorIndex) + { + + TPtrC expectedReply; + iRecvFlag = EFalse; + iHasReceiveDataToExpect=GetStringFromConfig(aSection, KExpectedReply(), expectedReply); + if ( iHasReceiveDataToExpect ) + { + iReceiveDataToExpect.Copy(expectedReply); + } + + TInt flags=0; + GetIntFromConfig(aSection, KFlags(), flags); + TBool useRecv2 = EFalse; + GetBoolFromConfig(aSection, KUseRecv2(), useRecv2); + + TBool boolCallTwice = EFalse; + GetBoolFromConfig(aSection, KCallTwice(), boolCallTwice); + + if (useRecv2) + { + INFO_PRINTF1(_L("Using Recv 2")); + INFO_PRINTF2(_L("Flags: %d"),flags); + TSockXfrLength actuallengthSent; + TInt errCode = iData->iBluetoothSocket->Recv(iDataToRead8, flags, actuallengthSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Recv failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iRecvFlag = ETrue; + iReceiveIndex = aAsyncErrorIndex; + } + + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->Recv(iDataToRead8, flags, actuallengthSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Recv failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iRecvFlag = ETrue; + iReceiveIndex = aAsyncErrorIndex; + } + } + TInt& lenSentInt=actuallengthSent(); + + INFO_PRINTF2(_L("Returned actual length received: %d"), lenSentInt); + if ( lenSentInt!=iDataToRead8.Length() ) + { + ERR_PRINTF3(_L("Returned length received: %d != Actual length received: %d"), lenSentInt, iDataToRead8.Length()); + SetBlockResult(EFail); + } + } + else + { + INFO_PRINTF1(_L("Using Recv 1")); + INFO_PRINTF2(_L("Flags: %d"),flags); + TInt errCode = iData->iBluetoothSocket->Recv(iDataToRead8, flags); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Recv failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iRecvFlag = ETrue; + iReceiveIndex = aAsyncErrorIndex; + } + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->Recv(iDataToRead8, flags); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Recv failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iRecvFlag = ETrue; + iReceiveIndex = aAsyncErrorIndex; + } + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdRecvFrom(const TDesC& aSection,const TInt aAsyncErrorIndex) + { + + TPtrC expectedReply; + iHasReceiveDataToExpect=GetStringFromConfig(aSection, KExpectedReply(), expectedReply); + if ( iHasReceiveDataToExpect ) + { + iReceiveDataToExpect.Copy(expectedReply); + } + + TBool useRecv2 = EFalse; + GetBoolFromConfig(aSection, KUseRecv2(), useRecv2); + + TInt flags = 0; // read in, if not found send 0 + GetIntFromConfig(aSection, KFlags(), flags); + TPtrC myTSockAddrName; + TBTSockAddr* myTSockAddr=NULL; + if( GetStringFromConfig(aSection, KTSockAddr(), myTSockAddrName)) + { + INFO_PRINTF2(_L("Binding with: %S TSockAddr"), &myTSockAddrName); + myTSockAddr=static_cast(GetDataObjectL(myTSockAddrName)); + if ( myTSockAddr!=NULL ) + { + if (!useRecv2) + { + TInt errCode = iData->iBluetoothSocket->RecvFrom(iDataToRead8, *myTSockAddr, flags); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("RecvFrom failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iReceiveIndex = aAsyncErrorIndex; + } + } + else + { + TSockXfrLength lenSent; + TInt errCode = iData->iBluetoothSocket->RecvFrom(iDataToRead8, *myTSockAddr, flags, lenSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("RecvFrom failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iReceiveIndex = aAsyncErrorIndex; + } + TInt& lenSentInt=lenSent(); + + INFO_PRINTF2(_L("Returned actual length received: %d"), lenSentInt); + if ( lenSentInt!=iDataToRead8.Length() ) + { + ERR_PRINTF3(_L("Returned length received: %d != Actual length received: %d"), lenSentInt, iDataToRead8.Length()); + SetBlockResult(EFail); + } + } + } + else + { + ERR_PRINTF1(_L("RecvFrom TBTSockAddr is NULL")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdRecvOneOrMore(const TDesC& aSection, const TInt aAsyncErrorIndex) + { + + TPtrC expectedReply; + iHasReceiveDataToExpect=GetStringFromConfig(aSection, KExpectedReply(), expectedReply); + if ( iHasReceiveDataToExpect ) + { + iReceiveDataToExpect.Copy(expectedReply); + } + + TInt flags=0; + GetIntFromConfig(aSection, KFlags(), flags); + + TBool boolCallTwice = EFalse; + GetBoolFromConfig(aSection, KCallTwice(), boolCallTwice); + + TSockXfrLength actuallengthSent; + TInt errCode = iData->iBluetoothSocket->RecvOneOrMore(iDataToRead8, flags, actuallengthSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("RecvOneOrMore failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iReceiveIndex = aAsyncErrorIndex; + } + + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->RecvOneOrMore(iDataToRead8, flags, actuallengthSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("RecvOneOrMore failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iReceiveIndex = aAsyncErrorIndex; + } + } + TInt& lenSentInt=actuallengthSent(); + INFO_PRINTF2(_L("Returned actual length received: %d"), lenSentInt); + if ( lenSentInt!=iDataToRead8.Length() ) + { + ERR_PRINTF3(_L("Returned length received: %d != Actual length received: %d"), lenSentInt, iDataToRead8.Length()); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdRemoteName(const TDesC& aSection) + { + T_TBTSockAddrChild addr; + iData->iBluetoothSocket->RemoteName(addr); + + TBTDevAddr currentAddr = addr.BTAddr(); + TBuf tmpBuf; + currentAddr.GetReadable(tmpBuf); + INFO_PRINTF2(_L("RemoteName() = 0x%S"),&tmpBuf); + + + TPtrC myTBTDevAddrName; + if( GetStringFromConfig(aSection, KTBTDevAddr(), myTBTDevAddrName)) + { + CT_BTDevAddrData* myTBTDevAddrData=static_cast(GetDataWrapperL(myTBTDevAddrName)); + TBTDevAddr btDevAddr = *myTBTDevAddrData->GetAddress(); + TBuf tmpBuf2; + btDevAddr.GetReadable(tmpBuf2); + if (tmpBuf2 != tmpBuf) + { + ERR_PRINTF3(_L("Expected address (%S) != actual address (%S)"),&tmpBuf2,&tmpBuf); + SetBlockResult(EFail); + } + } + else + { + TInt lhs; + TInt rhs; + TBool lhsGiven = EFalse; + TBool rhsGiven = EFalse; + lhsGiven = GetHexFromConfig(aSection, KHexBTAddrL(), lhs ); + rhsGiven = GetHexFromConfig(aSection, KHexBTAddrR(), rhs ); + + if (lhsGiven && rhsGiven) + { + TBTDevAddr btDevAddr (MAKE_TINT64(lhs, rhs)); + TBuf tmpBuf2; + btDevAddr.GetReadable(tmpBuf2); + if (tmpBuf2 != tmpBuf) + { + ERR_PRINTF3(_L("Expected address (%S) != actual address (%S)"),&tmpBuf2,&tmpBuf); + SetBlockResult(EFail); + } + } + } + + // Set in TBTSockAddr Data object so that it can be verified + TPtrC myTSockAddrName; + CT_BTSockAddrData* myTSockAddrData=NULL; + if( GetStringFromConfig(aSection, KTSockAddr(), myTSockAddrName)) + { + myTSockAddrData=static_cast(GetDataWrapperL(myTSockAddrName)); + if ( myTSockAddrData!=NULL ) + { + myTSockAddrData->SetObject(&addr,EFalse); + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdRequestChangeSupportedPacketTypes(const TDesC& aSection) + { + TInt mask = 0; + CT_BTUtil::GetTBTPacketType(*this, aSection, mask); + TInt errCode = iData->iBluetoothSocket->RequestChangeSupportedPacketTypes(mask); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("RequestChangeSupportedPacketTypes failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdRequestMasterRole() + { + TInt errCode = iData->iBluetoothSocket->RequestMasterRole(); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("RequestMasterRole failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdRequestSlaveRole() + { + TInt errCode = iData->iBluetoothSocket->RequestSlaveRole(); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("RequestSlaveRole failed with error code: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdSend(const TDesC& aSection, const TInt aAsyncErrorIndex) + { + TPtrC dataToSend; + iSendFlag = EFalse; + if( GetStringFromConfig(aSection, KData(), dataToSend)) + { + INFO_PRINTF2(_L("About to send: [%S]"), &dataToSend); + + TBuf8 dataToSend8(_L8("")); + dataToSend8.Copy(dataToSend); + + for ( ;dataToSend8.Length()iBluetoothSocket->Send(dataToSend8,flags,actuallengthSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Send failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iSendIndex = aAsyncErrorIndex; + } + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->Send(dataToSend8,flags,actuallengthSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Send failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iSendFlag = ETrue; + iSendIndex = aAsyncErrorIndex; + } + } + if (errCode == KErrNone) + { + TInt& lenSentInt=actuallengthSent(); + INFO_PRINTF2(_L("Returned length actual sent: %d"), lenSentInt); + if (lenSentInt != dataToSend8.Length()) + { + INFO_PRINTF3(_L("Returned length sent: %d != Actual length sent: %d"),lenSentInt,dataToSend8.Length()); + SetBlockResult(EFail); + } + } + } + else + { + INFO_PRINTF1(_L("Using Send 1")); + INFO_PRINTF2(_L("Flags: %d"),flags); + TInt errCode = iData->iBluetoothSocket->Send(dataToSend8,flags); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Send failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iSendFlag = ETrue; + iSendIndex = aAsyncErrorIndex; + } + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->Send(dataToSend8,flags); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("Send failed: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iSendFlag = ETrue; + iSendIndex = aAsyncErrorIndex; + } + } + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdSendTo(const TDesC& aSection,const TInt aAsyncErrorIndex) + { + TBool useSend2 =EFalse; + GetBoolFromConfig(aSection, KUseSend2(), useSend2); + + TInt flags = 0; // read in, if not found send 0 + GetIntFromConfig(aSection, KFlags(), flags); + TPtrC dataToSend; + if( GetStringFromConfig(aSection, KData(), dataToSend)) + { + INFO_PRINTF2(_L("About to send: [%S]"), &dataToSend); + TBool boolCallTwice = EFalse; + GetBoolFromConfig(aSection, KCallTwice(), boolCallTwice); + + TBuf8 dataToSend8(_L8("")); + dataToSend8.Copy(dataToSend); + TPtrC myTSockAddrName; + TBTSockAddr* myTSockAddr=NULL; + if( GetStringFromConfig(aSection, KTSockAddr(), myTSockAddrName)) + { + INFO_PRINTF2(_L("Binding with: %S TSockAddr"), &myTSockAddrName); + myTSockAddr=static_cast(GetDataObjectL(myTSockAddrName)); + if ( myTSockAddr!=NULL ) + { + if (!useSend2) + { + TInt errCode = iData->iBluetoothSocket->SendTo(dataToSend8,*myTSockAddr,flags); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("SendTo failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iSendIndex = aAsyncErrorIndex; + } + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->SendTo(dataToSend8,*myTSockAddr,flags); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("SendTo failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iSendIndex = aAsyncErrorIndex; + } + } + } + else + { + TSockXfrLength lenSent; + TInt errCode = iData->iBluetoothSocket->SendTo(dataToSend8,*myTSockAddr,flags,lenSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("SendTo failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iSendIndex = aAsyncErrorIndex; + } + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->SendTo(dataToSend8,*myTSockAddr,flags,lenSent); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("SendTo failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iSendIndex = aAsyncErrorIndex; + } + } + if (errCode == KErrNone) + { + TInt& lenSentInt=lenSent(); + INFO_PRINTF2(_L("Returned actual length sent: %d"), lenSentInt); + if (lenSentInt != dataToSend8.Length()) + { + INFO_PRINTF3(_L("Returned length sent: %d != Actual length sent: %d"),lenSentInt,dataToSend8.Length()); + } + } + + } + } + else + { + ERR_PRINTF1(_L("SendTo TBTSockAddr is NULL")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdSetAutomaticSniffMode(const TDesC& aSection) + { + + TBool sniffMode = EFalse; + GetBoolFromConfig(aSection, KSniffMode(), sniffMode); + + TInt errCode = KErrNone; + + TInt sniffDelay = 0; + if( GetIntFromConfig(aSection, KSniffDelay(), sniffDelay) ) + { + INFO_PRINTF3(_L("SetAutomaticSniffMode(%d, %d)"), sniffMode, sniffDelay); + errCode = iData->iBluetoothSocket->SetAutomaticSniffMode(sniffMode, sniffDelay); + } + else + { + INFO_PRINTF2(_L("SetAutomaticSniffMode(%d)"), sniffMode); + errCode = iData->iBluetoothSocket->SetAutomaticSniffMode(sniffMode); + } + + if (errCode!=KErrNone) + { + ERR_PRINTF2(_L("SetAutomaticSniffMode failed: %d"),errCode); + SetError(errCode); + } + } + +inline void CT_CBluetoothSocketData::DoCmdSetLocalPort(const TDesC& aSection) + { + TInt port; + + if( GetIntFromConfig(aSection, KPort(), port)) + { + INFO_PRINTF2(_L("Port to set is: %d"), port); + TInt errCode = iData->iBluetoothSocket->SetLocalPort(port); + if (errCode!=KErrNone) + { + ERR_PRINTF2(_L("SetLocalPort failed: %d"),errCode); + SetError(errCode); + } + } + else + { + ERR_PRINTF2(_L("Missing :%S"), &KPort()); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdSetNotifierL(const TDesC& aSection) + { + MBluetoothSocketNotifier* theNotifier = iData; + + TBool useAlternate =EFalse; + GetBoolFromConfig(aSection, KUseAlternateNotifier(), useAlternate); + if (useAlternate) + { + theNotifier=this; + } + + iData->iBluetoothSocket->SetNotifier(*theNotifier); + } + +inline void CT_CBluetoothSocketData::DoCmdSetOpt(const TDesC& aSection) + { + TPtrC optionName; + TPtrC optionLevel; + TInt optionNameValue; + TInt optionLevelValue; + TBool found = EFalse; + if( GetStringFromConfig(aSection, KOptionName(), optionName)) + { + found=CT_BTUtil::GetIntValue(optionName, optionNameValue); + //Report error but continue as it may still make sense + if (!found) + { + ERR_PRINTF2(_L("Option not found in lookup: %S"),&optionName); + SetBlockResult(EFail); + } + INFO_PRINTF3(_L("The name of the option to set: %S , its value: %d" ),&optionName, optionNameValue); + if( GetStringFromConfig(aSection, KOptionLevel(), optionLevel)) + { + found=CT_BTUtil::GetIntValue(optionLevel, optionLevelValue); + //Report error but continue as it may still make sense + if (!found) + { + ERR_PRINTF2(_L("Option Level not found in lookup: %S"),&optionLevel); + SetBlockResult(EFail); + } + INFO_PRINTF3(_L("The name of the option level to set: %S , its value: %d" ),&optionLevel, optionLevelValue); + TPtrC intOptionName; + if( GetStringFromConfig(aSection, KNamedIntOption(), intOptionName)) + { + INFO_PRINTF1(_L("Using SetOpt1 with named constant value")); + TInt intOption; + found=CT_BTUtil::GetIntValue(intOptionName, intOption); + //Report error but continue as it may still make sense + if (!found) + { + ERR_PRINTF2(_L("Option not found in lookup: %S"),&optionLevel); + SetBlockResult(EFail); + } + INFO_PRINTF3(_L("The name of the option level to set: %S its value: %d" ),&intOptionName, intOption); + iData->iBluetoothSocket->SetOpt(optionNameValue,optionLevelValue,intOption); + } + else + { + TInt intOption; + if( GetIntFromConfig(aSection, KIntOption(), intOption)) + { + INFO_PRINTF1(_L("Using SetOpt1 with int value")); + INFO_PRINTF2(_L("The value of the option level to set: %d" ),intOption); + iData->iBluetoothSocket->SetOpt(optionNameValue,optionLevelValue,intOption); + } + else + { + TPtrC desOption; + if( GetStringFromConfig(aSection, KDesOption(), desOption)) + { + INFO_PRINTF2(_L("The option level to set: %S" ),&desOption); + TBuf8 desOption8(_L8("")); + desOption8.Copy(desOption); + INFO_PRINTF3(_L("desOption len %d, desOption8 len %d" ),desOption.Length(), desOption8.Length()); + INFO_PRINTF1(_L("Using Deprecated SetOpt2")); + iData->iBluetoothSocket->SetOpt(optionNameValue,optionLevelValue,desOption8); + } + else + { + // Use default parameter for SetOpt i.e. call with two parameters only + INFO_PRINTF1(_L("Using Deprecated SetOpt2 with default value")); + iData->iBluetoothSocket->SetOpt(optionNameValue,optionLevelValue); + } + } + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + + +inline void CT_CBluetoothSocketData::DoCmdSetOption(const TDesC& aSection) + { + TPtrC optionName; + TPtrC optionLevel; + TInt optionNameValue; + TInt optionLevelValue; + TBool found = EFalse; + if( GetStringFromConfig(aSection, KOptionName(), optionName)) + { + found=CT_BTUtil::GetIntValue(optionName, optionNameValue); + //Report error but continue as it may still make sense + if (!found) + { + ERR_PRINTF2(_L("Option not found in lookup: %S"),&optionName); + SetBlockResult(EFail); + } + INFO_PRINTF3(_L("The name of the option to set: %S , its value: %d" ),&optionName, optionNameValue); + if( GetStringFromConfig(aSection, KOptionLevel(), optionLevel)) + { + found=CT_BTUtil::GetIntValue(optionLevel, optionLevelValue); + //Report error but continue as it may still make sense + if (!found) + { + ERR_PRINTF2(_L("Option Level not found in lookup: %S"),&optionLevel); + SetBlockResult(EFail); + } + + TPtrC desOption; + if( GetStringFromConfig(aSection, KDesOption(), desOption)) + { + INFO_PRINTF2(_L("The option level to set: %S" ),&desOption); + TBuf8 desOption8(_L8("")); + desOption8.Copy(desOption); + + INFO_PRINTF3(_L("desOption len %d, desOption8 len %d" ),desOption.Length(), desOption8.Length()); + INFO_PRINTF1(_L("Using SetOption")); + iData->iBluetoothSocket->SetOption(optionNameValue,optionLevelValue,desOption8); + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdShutdown(const TDesC& aSection, const TInt aAsyncErrorIndex) + { + + TBool boolCallTwice = EFalse; + GetBoolFromConfig(aSection, KCallTwice(), boolCallTwice); + + RSocket::TShutdown shutdown=RSocket::ENormal; + TBool dataOk=CT_BTUtil::GetShutdown(*this, aSection, shutdown); + + if ( dataOk ) + { + TInt err=KErrNone; + TBuf8 dataToSend8(_L8("")); + TPtrC disconnectData; + TBool hasDisconnectData=GetStringFromConfig(aSection, KDisconnectData(), disconnectData); + if( hasDisconnectData ) + { + INFO_PRINTF1(_L("Using second shutdown")); + dataToSend8.Copy(disconnectData); + err = iData->iBluetoothSocket->Shutdown(shutdown, dataToSend8, iDataAtDisconnect8); + } + else + { + INFO_PRINTF1(_L("Using standard shutdown")); + err = iData->iBluetoothSocket->Shutdown(shutdown); + } + if ( err==KErrNone ) + { + IncOutstanding(); + iShutdownIndex = aAsyncErrorIndex; + } + else + { + ERR_PRINTF2(_L("Shutdown of iBluetoothSocket failed with error code %d"), err); + SetError(err); + } + + if( boolCallTwice ) + { + if ( hasDisconnectData ) + { + err = iData->iBluetoothSocket->Shutdown(shutdown, dataToSend8, iDataAtDisconnect8); + } + else + { + err = iData->iBluetoothSocket->Shutdown(shutdown); + } + if (err != KErrNone ) + { + ERR_PRINTF2(_L("Shutdown of iBluetoothSocket failed with error code %d"),err); + SetError(err); + } + } + } + } + +inline void CT_CBluetoothSocketData::DoCmdTransfer(const TDesC& aSection) + { + INFO_PRINTF1(_L("Transfer the Bluetooth socket to this testddata object" )); + + TPtrC myRSocketName; + RSocket* myRSocket=NULL; + if( GetStringFromConfig(aSection, KRSocket(), myRSocketName)) + { + INFO_PRINTF2(_L("Transfering: %S to this RSocketServer"), &myRSocketName); + myRSocket=static_cast(GetDataObjectL(myRSocketName)); + if ( myRSocket!=NULL ) + { + TName myRSockName; + myRSocket->Name(myRSockName); + + if (myRSockName.Length()>0) + { + TInt err = iData->iBluetoothSocket->Transfer(iData->iSocketServer, myRSockName); + if (err == KErrNone ) + { + INFO_PRINTF1(_L("Transfer successful" )); + } + else + { + ERR_PRINTF2(_L("Transfer failed with error code %d"),err); + SetError(err); + } + } + else + { + ERR_PRINTF1(_L("Failed to fetch RSocket name")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF2(_L("Failed to fetch RSocket from %S"),&myRSocketName); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdWrite(const TDesC& aSection,const TInt aAsyncErrorIndex) + { + + TPtrC dataToSend; + iWriteFlag = EFalse; + if( GetStringFromConfig(aSection, KData(), dataToSend)) + { + INFO_PRINTF2(_L("About to write: [%S]"), &dataToSend); + + TBool boolCallTwice = EFalse; + GetBoolFromConfig(aSection, KCallTwice(), boolCallTwice); + + TBuf8 dataToSend8(_L8("")); + dataToSend8.Copy(dataToSend); + + for ( ;dataToSend8.Length()iBluetoothSocket->Write(dataToSend8); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("ActivateBasebandEventNotifier failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iWriteFlag = ETrue; + iSendIndex = aAsyncErrorIndex; + } + if( boolCallTwice ) + { + errCode = iData->iBluetoothSocket->Write(dataToSend8); + if (errCode != KErrNone) + { + ERR_PRINTF2(_L("ActivateBasebandEventNotifier failed with error code: %d"),errCode); + SetError(errCode); + } + else + { + IncOutstanding(); + iWriteFlag = ETrue; + iSendIndex = aAsyncErrorIndex; + } + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdTestMBSN_ExtensionInterfaceL(const TDesC& aSection) + { + TInt tmp; + void* theExtensionObjectPtr; + + TBool expectNull = EFalse; + GetBoolFromConfig(aSection, KExpectNull(), expectNull); + + if( GetIntFromConfig(aSection, KUid(), tmp)) + { + TUid uid=TUid::Uid(tmp); + TRAPD(err, iData->MBSN_ExtensionInterfaceL(uid,theExtensionObjectPtr)); + if( err!=KErrNone ) + { + ERR_PRINTF2(_L("MBSN_ExtensionInterfaceL err=%d"),err); + SetError(EFail); + } + + if (expectNull) + { + //Fail if not NULL + if (theExtensionObjectPtr!=NULL) + { + ERR_PRINTF1(_L("Expected Null pointer but object found")); + SetBlockResult(EFail); + } + } + else + { + //Fail if NULL + if (theExtensionObjectPtr!=NULL) + { + } + else + { + ERR_PRINTF1(_L("Expected object but found NULL")); + SetBlockResult(EFail); + } + } + } + else + { + ERR_PRINTF1(_L("GetIntFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdSetRsocketServerFromCBTSocket(const TDesC& aSection) + { + + // Get the blank session socket + TPtrC myCT_CBluetoothSocketDataName; + CT_CBluetoothSocketData* myCT_CBluetoothSocketData=NULL; + if( GetStringFromConfig(aSection, KCBluetoothSocket(), myCT_CBluetoothSocketDataName)) + { + myCT_CBluetoothSocketData=static_cast(GetDataWrapperL(myCT_CBluetoothSocketDataName)); + if ( myCT_CBluetoothSocketData!=NULL ) + { + iData->iSocketServer=myCT_CBluetoothSocketData->GetRServer(); + } + else + { + ERR_PRINTF1(_L("CBluetoothSocket is NULL")); + SetBlockResult(EFail); + } + } + else + { + ERR_PRINTF1(_L("GetStringFromConfig failed")); + SetBlockResult(EFail); + } + } + +inline void CT_CBluetoothSocketData::DoCmdSetTransferAble() + { + iData->iBluetoothSocket->SetOpt(KSOEnableTransfer, KSOLSocket, KProcPolicy().Package()); + } + +RSocketServ& CT_CBluetoothSocketData::GetRServer() + { + return iData->iSocketServer; + } + +// MBluetoothSocketNotifier implementation +void CT_CBluetoothSocketData::HandleConnectCompleteL(TInt aErr) + { + INFO_PRINTF2(_L("HandleConnectCompleteL : Status (%d)" ), aErr); + + if (aErr != KErrNone) + { + ERR_PRINTF2(_L("HandleConnectCompleteL called with error code: %d"),aErr); + SetAsyncError(iConnectIndex, aErr); + } + else + { + INFO_PRINTF1(_L("HandleConnectCompleteL successful" )); + } + + TBuf dataToRead(_L("")); + dataToRead.Copy(iDataToRead8); + INFO_PRINTF2(_L("Retrived: [%S]"), &dataToRead); + + if ( iHasConnectDataToExpect ) + { + TBuf dataExpected; + dataExpected.Copy(iConnectDataToExpect); + + // If dataExpected is shorter add filler chars as we did in send + // We just need to use a TBuf so that we can change it + if ( dataExpected.Length() dataToRead(_L("")); + dataToRead.Copy(iDataToRead8); + INFO_PRINTF2(_L("Retrived: [%S]"),&dataToRead); + + if ( iHasAcceptDataToExpect ) + { + TBuf dataExpected; + dataExpected.Copy(iAcceptDataToExpect); + + // If dataExpected is shorter add filler chars as we did in send + // We just need to use a TBuf so that we can change it + if ( dataExpected.Length() dataToRead(_L("")); + dataToRead.Copy(iDataToRead8); + INFO_PRINTF2(_L("Retrived: [%S]"), &dataToRead); + + if ( iHasReceiveDataToExpect ) + { + TBuf dataExpected; + dataExpected.Copy(iReceiveDataToExpect); + + // If dataExpected is shorter add filler chars as we did in send + // We just need to use a TBuf so that we can change it + if ( dataExpected.Length() tempBuffer(_L8("")); + tempBuffer.Copy(iMTUOptionBuffer); + INFO_PRINTF2(_L("HandleIoctlCompleteL = %S" ), &tempBuffer); + } + DecOutstanding(); + } + +void CT_CBluetoothSocketData::HandleActivateBasebandEventNotifierCompleteL(TInt aErr, TBTBasebandEventNotification & aEventNotification) + { + if (aErr != KErrNone) + { + ERR_PRINTF2(_L("HandleActivateBasebandEventNotifierCompleteL called with error code: %d"),aErr); + SetAsyncError(iNotifierIndex, aErr); + } + else + { + INFO_PRINTF1(_L("HandleActivateBasebandEventNotifierCompleteL successful" )); + INFO_PRINTF4(_L("Even type: %d Error code: %d Symbian Error Code: %d"), aEventNotification.EventType(), aEventNotification.ErrorCode(), aEventNotification.SymbianErrorCode()); + + + } + DecOutstanding(); + }