// Copyright (c) 2000-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 <e32math.h>

#include <utf.h>

#include <es_sock.h>

#include <btsdp.h>

#include "ipcinternals.h"

#include "sdpconsts.h"

#include "sdputil.h"

#include "SDPDatabase.h"

#include "DataEncoder.h"

#include "SDPAttribute.h"

#include "EncoderVisitor.h"

#include "ExtractorVisitor.h"

#include "agtypes.h"

#include "agutil.h"

#include "agconsts.h"

#include "ProtocolWrapper.h"

#include "requester.h"

#include "engine.h"

void CSdpRequesterBase::NewRequestL(const TBTDevAddr& aRemDev)

/**

	Attempts to connect to the remote device. 

	This is the first thing to do on receipt of a new request. 

**/

	{

	//If active, must only be active on the idle timer in idle state.

	__ASSERT_ALWAYS(iState == EIdle || !IsActive(), AgPanic(ESdpAgentTwoRequests));

	if(iState != EDisconnected && aRemDev == iRemoteAddress)

		{// Already Connected. Push us through to process state.

		Cancel(); //NB iState should be EIdle if we are here

		iState = EDisconnected;

		TRequestStatus* pS = &iStatus;

		User::RequestComplete(pS, KErrNone);

		SetActive();

		return;

		}

	iRetryCount = 0;

	iRemoteAddress = aRemDev;

	ConnectL();

	}

void CSdpRequesterBase::ConnectL()

/**

	Ask to connect to remote device address currently set-up in this active object.

	Note that we ensure that we are disconnected first...we could

	be connected to a different device.

**/

	{

	Disconnect();

	User::LeaveIfError(iIdleTimer.CreateLocal());

	User::LeaveIfError(iRequester.Open(iSdpSession));

	iRequester.Connect(iRemoteAddress, iStatus);

	SetActive();

	}

void CSdpRequesterBase::Disconnect()

/**

	Bring down a currently existing connection.

**/

	{

	iState = EDisconnected;

	iIdleTimer.Close();

	iRequester.Close();

	}

void CSdpRequesterBase::RetrieveResponseL()

/**

	The initial response to a search or attribute request contains

	a buffer size. To obtain the actual result, the response buffer

	has to be made big enough, and then have the actual result copied 

	into it from the server.

	RetrieveResponseL() does just this.

**/

	{

	if(!iResponseHBuf ||

		iResponseHBuf->Size() < iResultSize)

		{

		delete iResponseHBuf;

		iResponseHBuf = 0;

		iResponseHBuf = HBufC8::NewMaxL(iResultSize);

		}

	iResponse.Set(iResponseHBuf->Des());

	User::LeaveIfError(iRequester.RetrieveResult(iResponse));

	}

CSdpRequesterBase::	CSdpRequesterBase(RSdpSession& aSdpSession, CSdpAgentEng& aParent)

: CActive(CActive::EPriorityStandard),

 iSdpSession(aSdpSession),

 iParent(aParent),

 iRemoteAddress(0),

 iResponse(0,0)

/**

	Constructor: This is where ESock session and the CSdpAgentEng parent are provided.

	Other member variables are given default values.

**/

	{

	}

CSdpRequesterBase::~CSdpRequesterBase()

/**

	Destructor: Deletes buffer for responses. Ensures we are disconnected.

**/

	{

	delete iResponseHBuf;

	Disconnect();

	}

void CSdpRequesterBase::RunL()

/**

	Runs state machine.

	If no errors then:

	@verbatim

	state disconnected		->		state requesting

									The request was stored before

									connection, and now is made.

	state requesting		->		state idle.

									The request has completed. See

									if any further requests come in

									over a brief period.

	state idle				->		state disconnected 

									if idle state interrupted by new request,

									this is notional - the RunL is immediately

									called again to set state to requesting

									and issue the actual request.

	@endverbatim

**/

	{

	if(iStatus != KErrNone)

		{

		if(iState == ERequesting && 

		   ++iRetryCount < KRetryLimit)

			{// Comms Error in request. Try to connect again.

			ConnectL();

			return;

			}

		User::Leave(iStatus.Int());

		}

	switch(iState)

		{

	case EDisconnected: //Now connected

		iState = ERequesting;

		IssueRequestL();

		break;

	case ERequesting: // Actual request complete

		iState = EIdle;

		iIdleTimer.After(iStatus, KSdpAgentIdleTimeout);

		SetActive();

		//RequestCompleteL() might DELETE us, 

		//so it must be called last (before 'return').

		RequestCompleteL();

		return; 

	case EIdle:

		Reset();

		break;

		}

	}

void CSdpRequesterBase::Reset()

	{

	Disconnect(); //Causes iState to become EDisconnected.

	delete iResponseHBuf; //A chance to delete this - it may have become quite large

	iResponseHBuf = 0;

	iRetryCount = 0;

	}

void CSdpRequesterBase::DoCancel()

/**

	Cancels current asynchronous request.

	This will be either an SDP query being performed 

	through ESock or, if this CSdpRequesterBase is 

	in the idle state, a timer (set-up to perform

	a disconnection after a defined length of time).

**/

	{

	if(iState == EIdle)

		{

		__ASSERT_DEBUG(iIdleTimer.Handle(), AgPanic(ESdpAgentBadStateAtCancel));

		if(iIdleTimer.Handle())

			{

			iIdleTimer.Cancel();

			}

		}

	else

		{ 

		__ASSERT_DEBUG(iRequester.IsOpen(), AgPanic(ESdpAgentBadStateAtCancel));

		if(iRequester.IsOpen())

			{

			iRequester.Cancel();

			}

		}

	}

CSdpSearchRequester* CSdpSearchRequester::NewL(RSdpSession& aSdpSession, CSdpAgentEng& aParent)

/**

	Standard NewL method.

	Note: need to pass the client side object of the SDP service session,

	and the CSdpA.gentEng parent which is managing this CSdpAttributeRequester 

	active object.

**/

	{

	CSdpSearchRequester* self = new(ELeave) CSdpSearchRequester(aSdpSession, aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CSdpSearchRequester::~CSdpSearchRequester()

/**

	Destructor

**/

	{

	Cancel();

	}

void CSdpSearchRequester::SearchRequestL(const TBTDevAddr& aRemoteDev,

										 CSdpSearchPattern& aUUIDFilter,

										 TUint16 aMaxRecCount, 

										 const TDesC8& aContState)

/**

	Sets up appropriate member variables, then attempts to connect to remote device.

	(If connection is made the state machine takes over to make the actual 

	search request.)

**/

	{

	__ASSERT_DEBUG(iUUIDFilter==NULL,AgPanic(ESdpAgentTwoRequests));

	iUUIDFilter  = &aUUIDFilter;

	iMaxRecCount = aMaxRecCount;

	iContState.Set(aContState);

	NewRequestL(aRemoteDev);

	}

CSdpSearchRequester::CSdpSearchRequester(RSdpSession& aSdpSession, CSdpAgentEng& aParent)

:CSdpRequesterBase(aSdpSession, aParent),

 iContState(0,0)

/**

	Constructor: Adds this CSdpAttributeRequester to Active Scheduler.

	Sets parent, and passes client side object for 

	session with SDP server (currently ESock).

	Sets up cont state member to default 0 length descriptor. 

**/

	{

	CActiveScheduler::Add(this);

	}

void CSdpSearchRequester::ConstructL()

/**

	Currently does nothing.

**/

	{

	}

void CSdpSearchRequester::IssueRequestL()

/**

	Requester is now connected.

	Called down from requester base class.

	Time to actually issue the request

**/

	{

	iRequester.SdpSearchRequestL(iResultSize, 

								 *iUUIDFilter,

								 iMaxRecCount,

								 iContState, 

								 iStatus);

	SetActive();

	}

void CSdpSearchRequester::RequestCompleteL()

/**

	Response parameter format is

 @verbatim

		Total service record count		TUint16

		Current service record count	TUint16

		Service Record Handles			unadorned list of TUint32's

		Continuation State				1 + 0-16 bytes

 @endverbatim

**/

	{

	RetrieveResponseL(); // Use base class to suck result over IPC. Loads iResponse

	iUUIDFilter = NULL; // Indicates request is complete

	const TInt KRspTotalRecCountOffset = 0;

	const TInt KRspCurrentRecCountOffset = 2;

	const TInt KRspRecHandlesOffset = 4;

	const TInt KMinRspLength = 5; // From Spec. 2 + 2 + 1

	if(iResponse.Length() < KMinRspLength)

		User::Leave(KErrSdpBadResultData);

//

	TUint16 totalRecCount = BigEndian::Get16(&iResponse[KRspTotalRecCountOffset]);

	TUint16 currentRecCount = BigEndian::Get16(&iResponse[KRspCurrentRecCountOffset]);

	if(totalRecCount < currentRecCount)

		User::Leave(KErrSdpBadResultData);

	TInt byteCount = currentRecCount*sizeof(TSdpServRecordHandle);

	if(byteCount + KRspRecHandlesOffset + 1 > iResponse.Length())

		User::Leave(KErrSdpBadResultData);

//

	TInt contLen = iResponse[KRspRecHandlesOffset+byteCount];

	if(contLen > KSdpContinuationStateMaxLength ||

	   KRspRecHandlesOffset + byteCount + 1 + contLen != iResponse.Length())

		User::Leave(KErrSdpBadResultData);

//

	TPtrC8 recHandles(&iResponse[KRspRecHandlesOffset], byteCount);

	TPtrC8 contState;

	if(iResponse.Length()>KRspRecHandlesOffset + 1 + byteCount && contLen)

		{

		contState.Set(&iResponse[KRspRecHandlesOffset + 1 + byteCount], contLen);

		}

	else

		{

		contState.Set(0,0);

		}

	//Call this last: it may well end up calling back into this

	//CSdpSearchRequester object.

	iParent.HandleServiceSearchResponseL(totalRecCount, 

										 currentRecCount, 

										 recHandles, 

										 contState);

	}

void CSdpSearchRequester::Reset()

/**

	Called when base requester idle timer expires,

	and when an error is reported

	Cleans up and makes sure we really are disconnected.

**/

	{

	CSdpRequesterBase::Reset();

	}

void CSdpSearchRequester::DoCancel()

/**

	Cancels current asynchronous requests.

	This could be with the Sdp server (currently ESOCK)

	or if this CSdpRequesterBase is in idle state

	it cancels the time out timer (set-up to perform

	a disconnection after a defined length of time).

**/

	{

	CSdpRequesterBase::DoCancel();

	// We only need to reset iUUIDFilter if the Cancel

	// has been called externally.

	// If the state is EIdle, either iUUIDFilter is already NULL

	// or the Cancel is being called internally by NewRequestL 

	if(iState != EIdle)

		{

		iUUIDFilter = NULL; // Indicates request is complete

		}

	}

TInt CSdpSearchRequester::RunError(TInt aError)

/**

	Called automatically when a RunL leaves.

	Calls appropriate error handling function in the CSdpAgentEng parent.

**/

	{

	/*

	Make sure we are not active. RunL can leave after SetActive is called.

	*/

	Cancel(); 

	/*

	Indicates request has completed - albeit with an error.

	Do NOT rely on Cancel to have called DoCancel to do this.

	It will only do this if the CSdpSearchRequester is active.

	*/

	iUUIDFilter = NULL;

	/*

	We may or may not be disconnected.

	We may not be able to be re-connect

	We need to be in a known state after this call.

	So make sure we are disconnnected,

	and leave it to the user to try to

	reconnect. He will do this automatically

	by trying to start a new request.

	*/

	Reset();

	iParent.HandleServiceSearchError(aError);

	return KErrNone;

	}

CSdpAttributeRequester* CSdpAttributeRequester::NewL(RSdpSession& aSdpSession, CSdpAgentEng& aParent)

/**

	Standard NewL method.

	Note: need to pass the client side object of the SDP service session,

	and the CSdpA.gentEng parent which is managing this CSdpAttributeRequester 

	active object.

**/

	{

	CSdpAttributeRequester* self = new(ELeave) CSdpAttributeRequester(aSdpSession, aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CSdpAttributeRequester::~CSdpAttributeRequester()

/**

	Destructor

**/

	{

	Cancel();

	}

void CSdpAttributeRequester::AttributeRequestL(const TBTDevAddr& aRemoteDev,

											   TSdpServRecordHandle aHandle, 

											   TUint16 aMaxAttrByteCount,

											   CSdpAttrIdMatchList& aMatchList,

											   const TDesC8& aContState)

/**

	Sets up appropriate member variables, then attempts to connect to remote device.

	(If connection is made the state machine takes over to make the actual 

	attribute request.)

**/

	{

	__ASSERT_DEBUG(iMatchList==NULL,AgPanic(ESdpAgentTwoRequests));

	iHandle  = aHandle;

	iMaxAttrByteCount = aMaxAttrByteCount;

	iMatchList = &aMatchList;

	iContState.Set(aContState);

	NewRequestL(aRemoteDev);

	}

CSdpAttributeRequester::CSdpAttributeRequester(RSdpSession& aSdpSession, CSdpAgentEng& aParent)

:CSdpRequesterBase(aSdpSession, aParent),

 iContState(0,0)

/**

	Constructor: Adds this CSdpAttributeRequester to Active Scheduler.

	Sets parent, and passes client side object for 

	session with SDP server (currently ESock).

	Sets up cont state member to default 0 length descriptor. 

**/

	{

	CActiveScheduler::Add(this);

	}

void CSdpAttributeRequester::ConstructL()

/**

	Currently blank.

**/

	{

	}

void CSdpAttributeRequester::IssueRequestL()

/**

	Requester is now connected.

	Called down from requester base class.

	Time to actually issue the request

**/

	{

	iRequester.SdpAttributeRequestL(iResultSize, 

									iHandle,

									iMaxAttrByteCount,

									*iMatchList, 

									iContState, 

									iStatus);

	SetActive();

	}

void CSdpAttributeRequester::RequestCompleteL()

/**

	Response parameter format is

 @verbatim

		byte count of attr list		TUint16

		Attribute ID & Value		DES

		Continuation State			1 + 0-16 bytes

 @endverbatim

**/

	{

	RetrieveResponseL(); // Use base class to suck result over IPC. Loads iResponse

	iMatchList = NULL; // Indicates request is complete

	const TInt KRspTotalCountOffset = 0;

	const TInt KRspAttributeListOffset = 2;

	const TInt KMinRspLength = 5; // From Spec. 2 + 2 + 1

	if(iResponse.Length() < KMinRspLength)

		User::Leave(KErrSdpBadResultData);

//

	TUint16 byteCount = BigEndian::Get16(&iResponse[KRspTotalCountOffset]);

	if(byteCount + KRspAttributeListOffset + 1 > iResponse.Length())

		User::Leave(KErrSdpBadResultData);

//

	TInt contLen = iResponse[KRspAttributeListOffset+byteCount];

	if(contLen > KSdpContinuationStateMaxLength ||

	   KRspAttributeListOffset + byteCount + 1 + contLen != iResponse.Length())

		User::Leave(KErrSdpBadResultData);

//

	TPtrC8 attrList(&iResponse[KRspAttributeListOffset], byteCount);

	TPtrC8 contState;

	if(iResponse.Length()>KRspAttributeListOffset + 1 + byteCount && contLen)

		{

		contState.Set(&iResponse[KRspAttributeListOffset + 1 + byteCount], contLen);

		}

	else

		{

		contState.Set(0,0);

		}

	//Call this last: it may well end up calling back into this

	//CSdpAttributeRequester object.