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

// Bluetooth SDP verification tests

// 

//

#include <e32test.h>

#include <bluetooth/logger.h>

#include "TSDPSAS.h"

#include "MAttributeVisitor.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_TSDPSAS);

#endif

#ifdef _DEBUG

PANICCATEGORY("tsdpsas");

#endif

#undef STOPPING_MODE

#ifndef STOPPING_MODE

	//#define STOPPING_MODE

#endif

#undef SEVEN_LAYERS_BUG

#ifndef SEVEN_LAYERS_BUG

	//#define SEVEN_LAYERS_BUG

#endif

#define ONLY_CONTINUATION_AND_BROWSE

//If you want to see what actual attributes are coming back from an SAS query.

//#define PRINT_BUILDER

// constants

const TUint KUselessRecordHandle=0xffffffff;

const TUint KNonExistantUUID=0xffff;

const TUint KAttributeTestsServiceUUID=0x0011;

//const TInt KNumSdpVerificationTests=55;

const TInt KServiceRequestTest = 0;	// Number of the first test

const TInt KServiceAttributeRequestTest = 6;	// Number of the first test

const TInt KServiceSearchAttributeRequestTest = 29;	// Number of the first test

const TInt KSdpBrowseTest = 53;

const TInt KSdpLastTest = KSdpBrowseTest + 1;

const TInt KServiceRequestBITest = KServiceAttributeRequestTest - 2;

const TInt KServiceAttributeRequestBITest = KServiceSearchAttributeRequestTest - 3;

const TInt KServiceSearchAttributeRequestBITest = KSdpBrowseTest - 2;

const TInt KMinResponseSize = 8; // This is the 5 byte header + 2 byte size (zero) + cont bytes(zero)

const TInt KAttributeParamsSize = 11;

const TInt KServiceParamsSize16 = 7;

const TInt KServiceParamsSize32 = 9;

const TInt KServiceParamsSize128 = 21;

//const TInt KMaxCountSize = 2;

//const TInt KUuidListHeaderSize = 2;

const TInt KUuid16ParamSize = 3;

const TInt KUuid32ParamSize = 5;

const TInt KUuid128ParamSize = 17;

const TInt KServiceAttributeParamsSize16 = 12;

const TInt KServiceAttributeParamsSize32 = 14;

const TInt KServiceAttributeParamsSize128 = 26;

//const TInt KSdpSyncPointBase = 0x1000;

const TInt KSdpAttributeBigRange = 0x00000202;

// UUIDS (add to these as necessary) - see builddb.cpp

// UUIDS (add to these as necessary)

//const TUint32	KSdpContTestUUID = 0x100;

// Offsets and constants

const TInt KRecordHandleOffset = 9;

const TInt KTotalCountOffset = 5;

const TInt KCurrentCountOffset = 7;

const TInt KErrorCodeOffset = 5;

const TInt KAttributeByteCountOffset = 5;

const TInt KAttributeListOffset = 7;

GLREF_D TBTDevAddr devAddr;

//

// CSdpTestBase

//

CSdpTestBase::CSdpTestBase(CConsoleBase& aConsole)

:iConsole(aConsole),iRawTransactionId(0x0000)

	{

	}

CSdpTestBase::~CSdpTestBase()

	{

		iRawSock.Close();

	}

void CSdpTestBase::StartSDPServerL()

/**

	Builds up a static DB, and copies it into the RSdpDatabase

**/

	{

	}

void CSdpTestBase::RegisterDatabaseInServerL (CSdpDatabase&)

	{

	}

void CSdpTestBase::SendCloseL()

/**

Send info to remote device to indicate the tests have finished

**/

	{

	}

void CSdpTestBase::WaitForCloseL()

/**

Wait for input from the other side to show the tests have finished

(We only need to read one byte).

**/

	{

	}

void CSdpTestBase::SdpConnectL()

/**

Connect to remote SDP server

**/

	{

	TRequestStatus stat;

	TL2CAPSockAddr addr;

	addr.SetBTAddr(devAddr);

	addr.SetPort(1);

	iRawSock.Connect(addr, stat);

	User::WaitForRequest(stat);

	if(stat.Int())

		{

		iConsole.Printf(_L("Connection failed with error %d. Press any key.\r\n"), stat.Int());

		iConsole.Getch();

		}

	User::LeaveIfError(stat.Int());

	}

//

// TSDPHeader class

//

TSDPHeader::TSDPHeader()

:iPduId(0), iTransactionId(0), iParamLen(0)

	{

	}

TSDPHeader::TSDPHeader(TUint8 aPduId, TUint16 aTranId, TUint16 aLen)

:iPduId(aPduId), iTransactionId(aTranId), iParamLen(aLen)

	{

	}

void TSDPHeader::AppendHeader(TDes8& aBuf)

	{

	// Need to make sure endina-ness is OK (is this right)

	//

	TUint16 bigTranId = BigEndian::Get16((TUint8*)&iTransactionId);

	TUint16 bigLen = BigEndian::Get16((TUint8*)&iParamLen);

	aBuf.Append(&iPduId, 1);

	aBuf.Append((TUint8*)&bigTranId, 2);

	aBuf.Append((TUint8*)&bigLen, 2);

	}

//

// TServiceRequest class

//

TServiceRequest::TServiceRequest()

:iUuid(0), iSP(0), iMaxRecordCount(0), iUuidType(CSdpTestBase::EUuid16), iAutoDes(ETrue)

	{

	SetupDES();

	}

TServiceRequest::TServiceRequest(TUint8* aDes, 

								 TUUID aUuid, 

								 CSdpTestBase::TUuidType aUuidType,

								 TUint16 aMaxRecordCount)

:iUuid(0), iSP(0), iMaxRecordCount(0), iUuidType(CSdpTestBase::EUuid16), iAutoDes(EFalse)

	{

	Mem::Copy(iDes, aDes, 3);

	iUuid = aUuid;

	iUuidType = aUuidType;

	iMaxRecordCount = aMaxRecordCount;

	}

TServiceRequest::TServiceRequest(TUint8* aDes, 

								 CSdpSearchPattern& aSP, 

								 CSdpTestBase::TUuidType aUuidType,

								 TUint16 aMaxRecordCount)

:iUuid(0), iSP(0), iMaxRecordCount(0), iUuidType(CSdpTestBase::EUuid16), iAutoDes(EFalse)

	{

	Mem::Copy(iDes, aDes, 3);

	iSP = &aSP;

	iUuidType = aUuidType;

	iMaxRecordCount = aMaxRecordCount;

	}

TServiceRequest::TServiceRequest(TUUID aUuid, 

								 CSdpTestBase::TUuidType aUuidType,

								 TUint16 aMaxRecordCount)

:iUuid(aUuid), iSP(0), iMaxRecordCount(aMaxRecordCount), iUuidType(aUuidType), iAutoDes(ETrue)  

	{

	SetupDES();

	}

TServiceRequest::TServiceRequest(CSdpSearchPattern& aSP, 

								 CSdpTestBase::TUuidType aUuidType,

								 TUint16 aMaxRecordCount)

:iUuid(0), iSP(0), iMaxRecordCount(aMaxRecordCount), iUuidType(aUuidType), iAutoDes(ETrue)  

	{

	iSP = &aSP;

	SetupDES();

	}

void TServiceRequest::SetupDES()

	{

	if(iSP)

		//just set up first two bytes

		{

		iDes[0] = 0x35;

		switch(iUuidType)

			{

			case CSdpTestBase::EUuid128:

				iDes[1] = (TUint8)(KUuid128ParamSize*iSP->Count()); //take the length

				break;

			case CSdpTestBase::EUuid32:

				iDes[1] = (TUint8)(KUuid32ParamSize*iSP->Count()); //take the length

				break;

			default:

				iDes[1] = (TUint8)(KUuid16ParamSize*iSP->Count()); //take the length

			}

		}

	else

		{

		TUint8 validDes16[] = {0x35, 0x03, 0x19};

		TUint8 validDes32[] = {0x35, 0x05, 0x1a};

		TUint8 validDes128[] = {0x35, 0x11, 0x1c};

		switch(iUuidType)

			{

		case CSdpTestBase::EUuid16:

			Mem::Copy(iDes, validDes16, 3);

			break;

		case CSdpTestBase::EUuid32:

			Mem::Copy(iDes, validDes32, 3);

			break;

		default:

			Mem::Copy(iDes, validDes128, 3);

			}

		}

	}

void TServiceRequest::SetUuidType(CSdpTestBase::TUuidType aUuidType)

	{

	iUuidType = aUuidType;

	if(iAutoDes)

		{

		SetupDES();

		}

	}

void TServiceRequest::AppendRequest(TDes8& aBuf)

	{

	if(iSP)

		{

		aBuf.Append(iDes, 2); //just take the list header bytes ..then...

		for(TInt i = 0; i<iSP->Count(); i++)

			{

			TUUID uuid = iSP->At(i);

			TPtrC8 ptr16 = uuid.ShortestForm();

			TPtrC8 ptr32 = uuid.LongForm().Mid(0,4);

			TPtrC8 ptr128 = uuid.LongForm();

			switch(iUuidType)

				{

				case CSdpTestBase::EUuid128:

					aBuf.Append(0x1c);

					aBuf.Append(ptr128);

					break;

				case CSdpTestBase::EUuid32:

					aBuf.Append(0x1a);

					aBuf.Append(ptr32);

					break;

				default:

					aBuf.Append(0x19);

					aBuf.Append(ptr16);

				}

			}

		TUint16 bigCount = BigEndian::Get16((TUint8*)&iMaxRecordCount);

		aBuf.Append((TUint8*)&bigCount, 2);

		}

	else

		{

		TPtrC8 ptr16 = iUuid.ShortestForm();

		TPtrC8 ptr32 = iUuid.LongForm().Mid(0,4);

		TPtrC8 ptr128 = iUuid.LongForm();

		TUint16 bigCount = BigEndian::Get16((TUint8*)&iMaxRecordCount);

		aBuf.Append(iDes, 3); //....CHANGED

		switch(iUuidType)

			{

			case CSdpTestBase::EUuid128:

				aBuf.Append(ptr128);

				break;

			case CSdpTestBase::EUuid32:

				aBuf.Append(ptr32);

				break;

			default:

				aBuf.Append(ptr16);

			}

		aBuf.Append((TUint8*)&bigCount, 2);

		}

	}

//

// TAttributeRequest class

//

TAttributeRequest::TAttributeRequest()

:iRecordHandle(0), iMaxByteCount(0), iAttributeId(0), iAttributeIdRange(0), iAutoDes(ETrue)

	{

	Mem::FillZ(iDes, 0); 

	}

TAttributeRequest::TAttributeRequest(TUint32 aRecordHandle, TUint16 aMaxByteCount, TUint8* aDes, TUint16 aAttributeId)

:iRecordHandle(aRecordHandle), iMaxByteCount(aMaxByteCount), iAttributeId(aAttributeId), iAttributeIdRange(0), iAutoDes(EFalse)

	{

	Mem::Copy(iDes, aDes, 3);

	}

TAttributeRequest::TAttributeRequest(TUint32 aRecordHandle, TUint16 aMaxByteCount, TUint8* aDes, TUint32 aAttributeIdRange)

:iRecordHandle(aRecordHandle), iMaxByteCount(aMaxByteCount), iAttributeId(0), iAttributeIdRange(aAttributeIdRange), iAutoDes(EFalse)

	{

	Mem::Copy(iDes, aDes, 3);

	}

TAttributeRequest::TAttributeRequest(TUint32 aRecordHandle, TUint16 aMaxByteCount, TUint16 aAttributeId)

:iRecordHandle(aRecordHandle), iMaxByteCount(aMaxByteCount), iAttributeId(aAttributeId), iAttributeIdRange(0), iAutoDes(ETrue)

	{

	SetupDES();

	}

TAttributeRequest::TAttributeRequest(TUint32 aRecordHandle, TUint16 aMaxByteCount, TUint32 aAttributeIdRange)

:iRecordHandle(aRecordHandle), iMaxByteCount(aMaxByteCount), iAttributeId(0), iAttributeIdRange(aAttributeIdRange), iAutoDes(ETrue)

	{

	SetupDES();

	}

void TAttributeRequest::SetupDES()

	{

	TUint8 validDesId[] = {0x35, 0x03, 0x09};

	TUint8 validDesIdRange[] = {0x35, 0x05, 0x0a};

	if(iAttributeIdRange)

		{

		Mem::Copy(iDes, validDesIdRange, 3);

		}

	else

		{

		Mem::Copy(iDes, validDesId, 3);

		}

	}

void TAttributeRequest ::AppendRequest(TDes8& aBuf)

	{

	TUint32 bigHandle = BigEndian::Get32((TUint8*)&iRecordHandle);

	TUint16 bigCount = BigEndian::Get16((TUint8*)&iMaxByteCount);

	TUint16 bigId = BigEndian::Get16((TUint8*)&iAttributeId);;

	TUint32 bigId32 = BigEndian::Get32((TUint8*)&iAttributeIdRange);;

	aBuf.Append((TUint8*)&bigHandle, 4);

	aBuf.Append((TUint8*)&bigCount, 2);

	aBuf.Append(iDes, 3);

	if(iAttributeIdRange)

		aBuf.Append((TUint8*)&bigId32, 4);

	else

		aBuf.Append((TUint8*)&bigId, 2);

	}

//

// TServiceAttributeRequest class

//

TServiceAttributeRequest::TServiceAttributeRequest()

	{

	}

TServiceAttributeRequest::TServiceAttributeRequest(TUint8* aServiceDes, TUUID aServiceUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxByteCount, TUint8* aAttribDes, TUint16 aAttributeId)

	{

	iServiceRequest=TServiceRequest(aServiceDes, aServiceUuid, aUuidType, 0);

	iAttributeRequest=TAttributeRequest(0, aMaxByteCount, aAttribDes, aAttributeId);

	}

TServiceAttributeRequest::TServiceAttributeRequest(TUUID aServiceUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxByteCount, TUint16 aAttributeId)

	{

	iServiceRequest=TServiceRequest(aServiceUuid, aUuidType, 0);

	iAttributeRequest=TAttributeRequest(0, aMaxByteCount, aAttributeId);

	}

TServiceAttributeRequest::TServiceAttributeRequest(TUint8* aServiceDes, TUUID aServiceUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxByteCount, TUint8* aAttribDes, TUint32 aAttributeIdRange)

	{

	iServiceRequest=TServiceRequest(aServiceDes, aServiceUuid, aUuidType, 0);

	iAttributeRequest=TAttributeRequest(0, aMaxByteCount, aAttribDes, aAttributeIdRange);

	}

TServiceAttributeRequest::TServiceAttributeRequest(TUUID aServiceUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxByteCount, TUint32 aAttributeIdRange)

	{

	iServiceRequest=TServiceRequest(aServiceUuid, aUuidType, 0);

	iAttributeRequest=TAttributeRequest(0, aMaxByteCount, aAttributeIdRange);

	}

void TServiceAttributeRequest::SetUuidType(CSdpTestBase::TUuidType aUuidType)

	{

	iServiceRequest.SetUuidType(aUuidType);

	}

void TServiceAttributeRequest::AppendRequest(TDes8& aBuf)

	{

	TUint16 byteCount = iAttributeRequest.MaxByteCount();

	TUint16 bigCount = BigEndian::Get16((TUint8*)&byteCount);

	TUint attribId = 0;

	TUint16 bigAttributeId = 0;

	TUint32 bigAttributeIdRange = 0;

	if((attribId = iAttributeRequest.AttributeIdRange())!=0)

		{

		bigAttributeIdRange = BigEndian::Get32((TUint8*)&attribId);

		}

	else

		{

		attribId = iAttributeRequest.AttributeId();

		bigAttributeId = BigEndian::Get16((TUint8*)&attribId);

		}

	if(iServiceRequest.SP())

		//WARNING-> THIS 'IF' HAS NOT BEEN TESTED!

		{

		aBuf.Append(iServiceRequest.Des(), 2); //just take the list header bytes..then...

		for(TInt i = 0; i<iServiceRequest.SP()->Count(); i++)

			{

			TUUID uuid = iServiceRequest.SP()->At(i);

			TPtrC8 ptr16 = uuid.ShortestForm();

			TPtrC8 ptr32 = uuid.LongForm().Mid(0,4);

			TPtrC8 ptr128 = uuid.LongForm();

			switch(iServiceRequest.UuidType())

				{

				case CSdpTestBase::EUuid128:

					aBuf.Append(0x1c);

					aBuf.Append(ptr128);

					break;

				case CSdpTestBase::EUuid32:

					aBuf.Append(0x1a);

					aBuf.Append(ptr32);

					break;

				default:

					aBuf.Append(0x19);

					aBuf.Append(ptr16);

				}

			}

		}

	else

		{

		TUUID uuid = iServiceRequest.Uuid();

		TPtrC8 ptr16 = uuid.ShortestForm();

		TPtrC8 ptr32 = uuid.LongForm().Mid(0,4);

		TPtrC8 ptr128 = uuid.LongForm();

		aBuf.Append(iServiceRequest.Des(), 3);

		switch(iServiceRequest.UuidType())

			{

			case CSdpTestBase::EUuid128:

				aBuf.Append(ptr128);

				break;

			case CSdpTestBase::EUuid32:

				aBuf.Append(ptr32);

				break;

			default:

				aBuf.Append(ptr16);

			}

		}

	aBuf.Append((TUint8*)&bigCount, 2);

	aBuf.Append(iAttributeRequest.Des(), 3);

	if(bigAttributeIdRange)

		{

		aBuf.Append((TUint8*)&bigAttributeIdRange, 4);

		}

	else

		{

		aBuf.Append((TUint8*)&bigAttributeId, 2);

		}

	}

class CAttrPrintVisitor : public CBase, public MAttributeVisitor

	{

public:

	CAttrPrintVisitor(CConsoleBase& aConsole) : iConsole(aConsole) {iIndent=0;}

	~CAttrPrintVisitor() {/*iConsole.Getch();*/}

    void VisitAttributeL(CSdpAttr &aAttribute)

		{

		Indent();