// 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 "VendorSAP.h"

#include "vendorspecific.h"

#include "linkmgr.h"

#include "hcifacade.h"

#include "BTSec.h"

//Diagnostic string for security check failures, in builds without platsec

//diagnostics this will be NULL.

const char* const KVENDOR_SAP_NAME_DIAG = __PLATSEC_DIAGNOSTIC_STRING("Vendor SAP");

// only does IOCTLs

CVendorSAP* CVendorSAP::NewL(CLinkMgrProtocol& aProtocol)

	{

	return new(ELeave) CVendorSAP(aProtocol);

	}

CVendorSAP::CVendorSAP(CLinkMgrProtocol& aProtocol)

: iDebugEventQueue(_FOFF(TVendorDebugEvent, iEventLink)),

  iProtocol(aProtocol)

	{

	iProtocol.iVendorSpecificSAP = this;

	}

CVendorSAP::~CVendorSAP()

	{

	iProtocol.iVendorSpecificSAP = NULL;

	//need to empty the queue.

	while (!(iDebugEventQueue.IsEmpty()))

		{

		TVendorDebugEvent* theEvent = iDebugEventQueue.First();

		theEvent->iEventLink.Deque();

		delete theEvent;

		}

	}

void CVendorSAP::Ioctl(TUint aLevel,TUint aName,TDes8* aOption)

/**

**/

	{

	__ASSERT_DEBUG(iIoctlLevel == 0, Panic(EVendorTwoIoctls));

	__ASSERT_DEBUG(iIoctlName == 0, Panic(EVendorTwoIoctls));

	iIoctlLevel = aLevel;

	iIoctlName = aName;

	//Do security check on following Ioctls

	TInt rerr = KErrNone;

	switch(aName)

		{

		case KHCIWaitForVendorSpecificDebugEventIoctl:

		case KHCIWriteVendorSpecificFrameIoctl:

		case KHCIWriteVendorSpecificFrameNoEventExpectedIoctl:

			{

			//The above Ioctl require additional security checking, NetworkControl

			//in addition to the LocalServices that was required to create the SAP

			__ASSERT_DEBUG(iSecurityChecker, User::Panic(KSECURITY_PANIC, EBTPanicNullSecurityChecker));

			rerr = iSecurityChecker->CheckPolicy(KNETWORK_CONTROL, KVENDOR_SAP_NAME_DIAG);

			if (rerr != KErrNone)

				{

				NotifyIoctlComplete(rerr,

									KSolBtHCI,

									aName,

									NULL);

				}								

			break;

			}

		default:

		//	Other Ioctls require just LocalServices - effectively policed when BT socket is created/transferred

		break;	

		}

	if (rerr != KErrNone)

		{

		return;				

		}

	// have passed security check so continue to handle ioctl		

	switch(aName)

		{

		case KHCIWaitForVendorSpecificDebugEventIoctl:

			{

			/*

			If VendorSpecificWaitForDebugEvent ioctl 

			See if we can complete it synchronously

			*/

			TryToCompleteVendorDebugEventIoctl();	

			break;

			}

		case KHCIWriteVendorSpecificFrameIoctl:

			{

			if(aOption->Length() != sizeof(THCIWriteVendorSpecificFrameIoctl))

				{

				NotifyIoctlComplete(KErrBadDescriptor,

						KSolBtHCI,

						KHCIWriteVendorSpecificFrameIoctl,

						NULL);

				return;

				}

			const THCIWriteVendorSpecificFrameIoctl* ioctl =

				reinterpret_cast<const THCIWriteVendorSpecificFrameIoctl*>(aOption->Ptr());

			TRAPD(err,iProtocol.HCIFacade().VendorSpecificCommandL(ioctl->iOpcode, ioctl->iParams));

			if (err)

				{

				NotifyIoctlComplete(err,

									KSolBtHCI,

									KHCIWriteVendorSpecificFrameIoctl,

									NULL);

				}

			// if no error wait for event before completing

			break;

			}

		case KHCIWriteVendorSpecificFrameNoEventExpectedIoctl:

			{

			if(aOption->Length() != sizeof(THCIWriteVendorSpecificFrameIoctl))

				{

				NotifyIoctlComplete(KErrBadDescriptor,

						KSolBtHCI,

						KHCIWriteVendorSpecificFrameNoEventExpectedIoctl,

						NULL);

				return;

				}

			const THCIWriteVendorSpecificFrameIoctl* ioctl =

				reinterpret_cast<const THCIWriteVendorSpecificFrameIoctl*>(aOption->Ptr());

			TRAPD(err,iProtocol.HCIFacade().VendorSpecificCommandL(ioctl->iOpcode, ioctl->iParams));

			// notify completion now though really could wait until delivered from q

			NotifyIoctlComplete(err,

								KSolBtHCI,

								KHCIWriteVendorSpecificFrameNoEventExpectedIoctl,

								NULL);

			break;

			}

		default:

			NotifyIoctlComplete(

				KErrNotSupported,

				iIoctlLevel,

				iIoctlName,

				NULL

			);

			break;

		} // END Switch

	}

void CVendorSAP::VendorCommandCompleteEvent(TInt aErr, const TDesC8* aEvent)

	{

	if(iIoctlName == KHCIWriteVendorSpecificFrameIoctl)

		{

		/*

		A client is waiting for this.

		*/

		NotifyIoctlComplete(aErr, iIoctlLevel, KHCIWriteVendorSpecificFrameIoctl, aEvent);

		}

	}

void CVendorSAP::VendorDebugEvent(TInt aErr, const TDesC8* aEvent)

	{

	// Some events will not contain an event descriptor.

	TPtrC8 eventDesc = aEvent?*aEvent:KNullDesC8; 

	// Holds the data from an *expected* event (expected as in conduit said so!).

	TVendorDebugEvent* newEvent = NewDebugEventData(eventDesc, aErr);	

	if(newEvent)

		{

		iDebugEventQueue.AddLast(*newEvent); // add this event to the end of the list of events already queued

		}

	else

		{

		NotifyIoctlComplete(KErrNoMemory,

							iIoctlLevel,

							iIoctlName,

							NULL);

		return;

		}

	TryToCompleteVendorDebugEventIoctl();

	}

TInt CVendorSAP::SecurityCheck(MProvdSecurityChecker *aSecurityChecker)

	{

	__ASSERT_ALWAYS(aSecurityChecker, User::Panic(KSECURITY_PANIC, EBTPanicNullSecurityChecker));

	iSecurityChecker = aSecurityChecker;

	return iSecurityChecker->CheckPolicy(KLOCAL_SERVICES, KVENDOR_SAP_NAME_DIAG);				

	}

void CVendorSAP::NotifyIoctlComplete(TInt aErr, TUint aLevel, TUint aName, const TDesC8* aBuffer)

	{

	if (iIoctlLevel == aLevel && iIoctlName == aName)

		{

		if (aErr == KErrNone)

			{

			if(iSocket)

				iSocket->IoctlComplete(const_cast<TDesC8*>(aBuffer));

			}

		else

			{

			if(iSocket)

				iSocket->Error(aErr, MSocketNotify::EErrorIoctl);

			}

		}

	iIoctlLevel=0;

	iIoctlName=0;

	}

CVendorSAP::TVendorDebugEvent* CVendorSAP::NewDebugEventData(const TDesC8& aBuf, TInt aError)

/**

@param aBuf The Vendor event buffer. Must not be NULL

**/

	{

	TVendorDebugEvent* event = new TVendorDebugEvent;

	if(!event)

		{

		return 0;

		}

	event->iEventBuf.Copy(aBuf.Left(Min(CHctlCommandFrame::KHCIMaxCommandLength, aBuf.Length())));

	event->iEventError = aError;

	return event;

	}

void CVendorSAP::TryToCompleteVendorDebugEventIoctl()

	{

	// check to see if anyone expecting a debug event completion

	if (iIoctlName != KHCIWaitForVendorSpecificDebugEventIoctl)

		{

		return;

		}

	// nothing to do

	if(iDebugEventQueue.IsEmpty())

		{

		return;

		}

	TVendorDebugEvent* theEvent = iDebugEventQueue.First();

	// belt and braces!

	if(theEvent == NULL)

		{

		return;

		}

	// De-queue the event, as it is being consumed

	theEvent->iEventLink.Deque();

	// Complete the waiting ioctl, passing the the first appropriate

	// event in the queue back up.

	NotifyIoctlComplete(

		theEvent->iEventError,

		KSolBtHCI,

		KHCIWaitForVendorSpecificDebugEventIoctl,

		&(theEvent->iEventBuf)

		);

	// Event has been consumed, may now be deleted

	delete theEvent;

	}

void CVendorSAP::Start()

	{

	// do nothing

	}

void CVendorSAP::LocalName(TSockAddr& /*aAddr*/) const

	{

	Panic(EVendorSAPBadCall);

	}

TInt CVendorSAP::SetLocalName(TSockAddr& /*aAddr*/)

	{

	Panic(EVendorSAPBadCall);

	return KErrNotSupported;

	}

void CVendorSAP::RemName(TSockAddr& /*aAddr*/) const

	{

	Panic(EVendorSAPBadCall);

	}

TInt CVendorSAP::SetRemName(TSockAddr& /*aAddr*/)

	{

	Panic(EVendorSAPBadCall);

	return KErrNotSupported;

	}

TInt CVendorSAP::GetOption(TUint /*aLevel*/,TUint /*aName*/,TDes8& /*aOption*/) const

	{

	Panic(EVendorSAPBadCall);

	return KErrNotSupported;

	}

void CVendorSAP::CancelIoctl(TUint __DEBUG_ONLY(aLevel),TUint __DEBUG_ONLY(aName))

	{

	__ASSERT_DEBUG(iIoctlLevel == aLevel, Panic(EVendorSAPBadIoctlCancel));

	__ASSERT_DEBUG(iIoctlName == aName, Panic(EVendorSAPBadIoctlCancel));

	iIoctlName = 0;

	iIoctlLevel = 0;

	}

TInt CVendorSAP::SetOption(TUint /*aLevel*/,TUint /*aName*/,const TDesC8& /*aOption*/)

	{

	Panic(EVendorSAPBadCall);

	return KErrNotSupported;

	}

void CVendorSAP::ActiveOpen()

	{

	Panic(EVendorSAPBadCall);

	}

void CVendorSAP::ActiveOpen(const TDesC8& /*aConnectionData*/)

	{

	Panic(EVendorSAPBadCall);

	}

TInt CVendorSAP::PassiveOpen(TUint /*aQueSize*/)

	{

	Panic(EVendorSAPBadCall);

	return KErrNotSupported;

	}

TInt CVendorSAP::PassiveOpen(TUint /*aQueSize*/,const TDesC8& /*aConnectionData*/)

	{

	Panic(EVendorSAPBadCall);

	return KErrNotSupported;

	}

void CVendorSAP::AutoBind()

	{

	Panic(EVendorSAPBadCall);

	}

TUint CVendorSAP::Write(const TDesC8& /*aDesc*/, TUint /*aOptions*/, TSockAddr* /*aAddr*/)

	{

	Panic(EVendorSAPBadCall);

	return 0;

	}

void CVendorSAP::GetData(TDes8& /*aDesc*/,TUint /*aOptions*/,TSockAddr* /*aAddr*/)

	{

	Panic(EVendorSAPBadCall);

	}

void CVendorSAP::Shutdown(TCloseType aCloseType)

	{

	if (aCloseType == ENormal)

		{

		iSocket->CanClose();

		}

	}

void CVendorSAP::Shutdown(TCloseType /*aOption*/,const TDesC8& /*aDisconnectionData*/)

	{

	Panic(EVendorSAPBadCall);

	}