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

// BT test code to emulate certain aspects of host controller over null modem

// for testing stack behaviour on invalid events etc from HC

// 

//

#include <e32test.h>

#include <es_sock.h>

#include <f32file.h>

#include <e32test.h>

#include <c32comm.h>

#include "hcemulator.h"

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV")

#define LDD_NAME _L("ECOMM")

#else  // __GCC32__

#define PDD_NAME _L("EUART1")

#define LDD_NAME _L("ECOMM")

// #define ETNA_PDD_NAME _L("EUART2") // for debugging over Com2

#endif

#define _EMULATOR_HWFC

#undef  _EMULATOR_HWFC

//The #define below was introduced for DEF074193. 

//This defect was subsumed by INC075303.

//#define DISCONNECT_ON_ACCEPT //Tweak HCEmulator to disconnect instead of completing an Accept_Connection_Request cmd

GLDEF_D RTest test(_L("Host Controller Emulator"));

CHCEmulator* CHCEmulator::NewL(CConsoleBase& aConsole)

	{

	CHCEmulator* e = new (ELeave) CHCEmulator(aConsole);

	CleanupStack::PushL(e);

	e->ConstructL(aConsole);

	CleanupStack::Pop(e);

	return e;

	}

CHCEmulator::CHCEmulator(CConsoleBase& aConsole) : iConsole(aConsole), iPacket(NULL,0), iHCAddress(KEmulatedHCAddress)

	{

	}

CHCEmulator::~CHCEmulator()

	{

	delete iReader;

	delete iWriter;

	delete iInquiryTimer;

	delete iActiveConsole;

	delete iConnectionsConsole;

	delete iPacketBuffer;

	iLocalName.Close();

	iConnections.Close();

	iPort.Close();

	iCommServer.Close();

	}

void CHCEmulator::ConstructL(CConsoleBase& aConsole)

	{

	User::LeaveIfError(iCommServer.Connect());

	User::LeaveIfError(iCommServer.LoadCommModule(_L("ECUART")));

	iConsole.Printf(_L("Select COM port that NULL modem lead is connected to (0/1/2/3/4/5/6/7/8/9):"));

	TChar port;

	do

		{

		port = iConsole.Getch();

		}

	while (port != '0' && 

		   port != '1' && 

		   port != '2' && 

		   port != '3' && 

		   port != '4' && 

		   port != '5' && 

		   port != '6' && 

		   port != '7' && 

		   port != '8' && 

		   port != '9');

	TBuf<7> portName;

	portName = _L("COMM::");

	portName.Append(port);

	TInt ret=iPort.Open(iCommServer,portName,ECommExclusive);

	if (ret!=KErrNone)

		User::Leave(ret);

	iPort.ResetBuffers();

	TCommConfig config;

	iPort.Config(config);

	config().iRate=EBps115200;					// 115200 for CSR, 57600 for EBDK builds of stack

	config().iDataBits=EData8;

	config().iParity=EParityNone;			    // no parity

	config().iStopBits=EStop1;                 // 1 stop bit

#ifdef _EMULATOR_HWFC

	config().iHandshake=KConfigObeyCTS | KConfigFreeRTS | KConfigFreeDTR;        // no handshaking;

#else

	config().iHandshake=0;

#endif

	User::LeaveIfError(iPort.SetConfig(config));

//	iPort.SetSignals(KSignalDTEInputs,0);			// allow other side to send

#ifdef _EMULATOR_HWFC

	iPort.SetSignals(KSignalRTS,KSignalDTR);

#endif

	iReader = CActiveReader::NewL(aConsole, *this, iPort);

	iWriter = CActiveWriter::NewL(aConsole, *this, iPort);

	iInquiryTimer = CInquiryTimer::NewL(*this);

	iActiveConsole = CActiveConsole::NewL(aConsole, *this);

	iConnectionsConsole = AutoSizeNewL(_L("Emulated Connections"), TSize(60,20));

	iPacketBuffer = HBufC8::NewL(KWriteBufSize);

	iPacket.Set(iPacketBuffer->Des());

	iInquiryAddresses.Copy(&KDeviceAddresses[0], KEmulatedInquiryNumberDevicesFound);

	iInquiryNames.Copy(&KDeviceNames[0], KEmulatedInquiryNumberDevicesFound);

	iLocalName.Create(248);

	iLocalName.Append(KDefaultLocalName);

	}

CConsoleBase* CHCEmulator::AutoSizeNewL(const TDesC& aTitle, TSize aSize)

	{

	// Try to create a console of our preferred size, otherwise we

	// guess the screen is too small and use its entirety.

	CConsoleBase* console = NULL;

	TRAPD(err, console = Console::NewL(aTitle, aSize));

	if (err != KErrNone)

		{

		// If we leave now it is not because of offscreen drawing.

		console = Console::NewL(aTitle, TSize(KConsFullScreen, KConsFullScreen));

		}

	return console;

	}

void CHCEmulator::Start()

	{

	CActiveScheduler::Start();

	}

void CHCEmulator::Stop()

	{

	CActiveScheduler::Stop();

	}

void CHCEmulator::CommandStatusEvent(TUint16 aOpcode, TUint8 aError)

	{

	iConsole.Printf(_L("Sending C.S.E (opcode 0x%04x, error 0x%02x)...\n"), aOpcode, aError);

	BuildAndWriteCommandPacket(ECommandStatusEvent, aOpcode, aError);

	}

void CHCEmulator::InquiryStartEvent(TUint8 aError)

	{

	iConsole.Printf(_L("Starting inquiry...")); //FIXME IAC

	iCurrentInquiryResponse = 0;

	iInquiryTimer->Start();

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KInquiryOpcode, aError);

	}

void CHCEmulator::DefaultCommandCompleteEvent(TUint16 aOpcode, TUint8 aError)

	{

	iConsole.Printf(_L("Sending C.C.E (opcode 0x%04x, error 0x%02x)...\n"), aOpcode, aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, aOpcode, aError);

	}

void CHCEmulator::ReadBufferSizeCompleteEvent(TUint8 aError)

	{

	iConsole.Printf(_L("Sending C.C.E (opcode ReadBufSize, error 0x%02x)...\n"), aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KReadBufferSizeOpcode, aError);

	}

void CHCEmulator::ReadBDAddrCompleteEvent(TUint8 aError)

	{

	iConsole.Printf(_L("Sending C.C.E (opcode ReadBDAddr, error 0x%02x)...\n"), aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KReadBdaddrOpcode, aError);

	}

void CHCEmulator::ReadLocalNameCompleteEvent(TUint8 aError)

	{

	iConsole.Printf(_L("Sending C.C.E (opcode ReadLocalName, error 0x%02x)...\n"), aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KReadLocalNameOpcode, aError);

	}

void CHCEmulator::InquiryCompleteEvent(TUint8 aError)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending InquiryComplete Event (error 0x%02x)...\n"), aError);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIInquiryCompleteEventCode);

	PutBytes(KHCIInquiryCompleteEventLength);

	PutBytes(aError);

	WritePacket();

	}

void CHCEmulator::InquiryResultEvent()

	{

	TInt resultsInPacket = Min(((iCurrentInquiryResponse % 5) + 1) , (KEmulatedInquiryNumberDevicesFound - iCurrentInquiryResponse));

	ClearPacket();

	TInt error = KHCIOK;

	iConsole.Printf(_L("Sending InquiryResult Event (error 0x%02x)...\n"), error);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIInquiryResultEventCode);

	PutBytes(1 + (14 * resultsInPacket));

	PutBytes(resultsInPacket);

	for (TInt i = 0; i < resultsInPacket; i++)

		{

		// stick them all in one event!

		PutAddress(iInquiryAddresses[iCurrentInquiryResponse + i]);

		PutBytes(KEmulatedInquiryPageScanRepetionMode);

		PutBytes(KEmulatedInquiryPageScanPeriodMode);

		PutBytes(KEmulatedInquiryPageScanMode);

		PutBytes(KEmulatedInquiryClassOfDevice,3);

		PutBytes(KEmulatedInquiryClockOffset,2);

		}

	WritePacket();

	iCurrentInquiryResponse += resultsInPacket;

	// Wait for another result if we've not done them all, else complete inquiry

	if(iCurrentInquiryResponse < KEmulatedInquiryNumberDevicesFound)

		{

		iInquiryTimer->Start();

		}

	else

		{

		InquiryCompleteEvent(KHCIOK);

		}

	}

void CHCEmulator::ConnectionCompleteEvent(TUint8 aError, TLinkType /*aType*/)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending ConnectionComplete Event (error 0x%02x)...\n"), aError);

	const TBTConnect& newConnection = iConnections[iConnections.Count()-1];

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIConnectionCompleteEventCode);

	PutBytes(KHCIConnectionCompleteEventLength);

	// test for what happens if we createconnection while inquiry is active

	if (iInquiryTimer->IsActive())

		PutBytes(KHCICommandDisallowed);

	else

		PutBytes(aError);

	PutBytes(newConnection.iConnH,2);

	PutAddress(newConnection.iBdaddr); // <-- test signaller by changing this address

	PutBytes(newConnection.iLinkType);

	PutBytes(newConnection.iEncryptMode);

	WritePacket();

	}

void CHCEmulator::InquiryCancelCompleteEvent(TUint8 aError)

	{

	iInquiryTimer->Cancel();

	DefaultCommandCompleteEvent(KInquiryCancelOpcode, aError); 

	}

void CHCEmulator::ConnectionRequestEvent(const TBTDevAddr& aAddr, TUint aCoD, TLinkType aType)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending Connection Request event...\n"));

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIConnectionRequestEventCode);

	PutBytes(KHCIConnectionRequestEventLength);

	PutAddress(aAddr);

	PutBytes(aCoD,3);

	PutBytes(aType);

	WritePacket();

	}

void CHCEmulator::DisconnectionCompleteEvent(TUint8 aError, THCIConnHandle aConnH, TUint8 aReason)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending DisconnectComplete Event (error 0x%02x)...\n"), aError);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIDisconnectionCompleteEventCode);

	PutBytes(KHCIDisconnectionCompleteEventLength);

	PutBytes(aError);

	PutBytes(aConnH, 2);

	PutBytes(aReason);

	WritePacket();

	}

void CHCEmulator::WriteLinkPolicySettingsCompleteEvent(TUint8 aError, THCIConnHandle aConnH)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending WriteLinkPolicySettingsComplete Event (error 0x%02x)...\n"), aError);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCICommandCompleteEventCode);

	PutBytes(KHCIWriteLinkPolicySettingsCompleteLength);

	PutBytes(1); //1 command token

	PutBytes(KWriteLinkPolicySettingsOpcode,2);

	PutBytes(aError);

	PutBytes(aConnH, 2);

	WritePacket();	

	}

void CHCEmulator::ReadClockOffsetCompleteEvent(TUint8 aError, THCIConnHandle aConnH)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending ReadClockOffsetComplete Event (error 0x%02x)...\n"), aError);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIReadClockOffsetCompleteEventCode);

	PutBytes(KHCIReadClockOffsetCompleteLength);

	PutBytes(aError);

	PutBytes(aConnH, 2);

	PutBytes(KEmulatedClockOffset,2);

	WritePacket();	

	}

void CHCEmulator::ConnectionPacketTypeChangedEvent(TUint8 aError, THCIConnHandle aConnH)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending ConnectionPacketTypeChanged Event (error 0x%02x)...\n"), aError);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIConnectionPacketTypeChangedCode);

	PutBytes(KHCIConnectionPacketTypeChangedLength);

	PutBytes(aError);

	PutBytes(aConnH, 2);

	PutBytes(KEmulatedChangedPacketType,2);

	WritePacket();	

	}

void CHCEmulator::ReadRemoteSupportedFeaturesCompleteEvent(TUint8 aError, THCIConnHandle aConnH)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending ReadRemoteSupportedFeaturesComplete Event (error 0x%02x)...\n"), aError);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIReadRemoteSupportedFeaturesCode);

	PutBytes(KHCIReadRemoteSupportedFeaturesLength);

	PutBytes(aError);

	PutBytes(aConnH, 2);

	PutBytes(KEmulatedRemoteSupportedFeatures1,4);

	PutBytes(KEmulatedRemoteSupportedFeatures2,4);

	WritePacket();	

	}

void CHCEmulator::ReadRemoteVersionInfoCompleteEvent(TUint8 aError, THCIConnHandle aConnH)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending ReadRemoteVersionInfoComplete Event (error 0x%02x)...\n"), aError);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIReadRemoteVersionInfoCode);

	PutBytes(KHCIReadRemoteVersionInfoLength);

	PutBytes(aError);

	PutBytes(aConnH, 2);

	PutBytes(KEmulatedRemoteVersionInfo1,4);

	PutBytes(KEmulatedRemoteVersionInfo2,1);

	WritePacket();	

	}

void CHCEmulator::ReadRemoteNameCompleteEvent(TUint8 aError, const TBTDevAddr& aAddr, const TDesC8& aName)

	{

	ClearPacket();

	iConsole.Printf(_L("Sending C.C.E (opcode ReadRemoteName, error 0x%02x)...\n"), aError);

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCIRemoteNameRequestCompleteEventCode);

	PutBytes(KHCIRemoteNameReqCompleteEventPacketLength);

	PutBytes(aError);

	PutAddress(aAddr);

	PutName(aName);

	WritePacket();

	}

void CHCEmulator::ReadLocalSupportedFeaturesCompleteEvent(TUint8 aError)

	{	

	iConsole.Printf(_L("Sending C.C.E (opcode ReadLocalSupportedFeatures, error 0x%02x)...\n"), aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KReadLocalSupportedFeaturesOpcode, aError);

	}

void CHCEmulator::ReadLocalVersionInfoCompleteEvent(TUint8 aError)

	{	

	iConsole.Printf(_L("Sending C.C.E (opcode ReadLocalVersionInformation, error 0x%02x)...\n"), aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KReadLocalVersionInfoOpcode, aError);

	}

void CHCEmulator::WriteVoiceSettingCompleteEvent(TUint8 aError)

	{

	iConsole.Printf(_L("Sending C.C.E (opcode WriteVoiceSetting, error 0x%02x)...\n"), aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KWriteVoiceSettingOpcode, aError);	

	}

void CHCEmulator::WriteCurrentIACLAPCompleteEvent(TUint8 aError)

	{

	iConsole.Printf(_L("Sending C.C.E (opcode WriteVoiceSetting, error 0x%02x)...\n"), aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KWriteCurrentIACLAPOpcode, aError);	

	}

void CHCEmulator::ReadClassOfDeviceCompleteEvent(TUint8 aError)

	{

	iConsole.Printf(_L("Sending C.C.E (opcode ReadClassOfDevice, error 0x%02x)...\n"), aError);

	BuildAndWriteCommandPacket(ECommandCompleteEvent, KReadClassOfDeviceOpcode, aError);	

	}

void CHCEmulator::VendorSpecificDebugCompleteEvent(TUint16 aOpCode, const TDesC8& aRemainderBuf)

	{

	ClearPacket();

	//  Just send back the payload we got in Vendor Specific Command. This is used by

	//  the tproxy HCIProxy test program, to be found in HCIProxy's directory.

	const TUint KFixedParamSize = 3;

	const TUint KMaxUserParamSize  = 255 - KFixedParamSize;

	TUint userParamSize = (aRemainderBuf.Length() < KMaxUserParamSize) ?

						   aRemainderBuf.Length() : KMaxUserParamSize;

	PutBytes(KHCIUARTEventHeader);

	PutBytes(KHCICommandCompleteEventCode);

	PutBytes(KFixedParamSize + userParamSize);

	PutBytes(1);	// numPackets

	PutBytes(aOpCode, 2);

	for (int i = 0; i < userParamSize; i++)

		PutBytes(aRemainderBuf[i]);

	iConsole.Printf(_L("Sending C.C.E (opcode VendorSpecificDebug), user param size %d...\n"),

					userParamSize);

	WritePacket();

	}

void CHCEmulator::ACLDataReceived(const TDesC8& aConnHandleFlagsBuf, const TDesC8& aRemainderBuf)

	{

	// send it back!

	// RFCOMM might need to tweak the data to allow SC n to connect to (say) SC (n+1)

	BuildAndWriteDataPacket(aConnHandleFlagsBuf, aRemainderBuf);

	// send ACL completed packets event