// Copyright (c) 2003-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:

// Implementation of proxy SAP.

// 

//

#include <bluetooth/logger.h>

#include "ProxySAP.h"

#include "linkutil.h"

#include "linkconsts.h"

#include "RawConduit.h"

#include "physicallinksmanager.h"

#include "Basebandmodel.h"

#include "BTSec.h"

#include "linkmgr.h"

#include <bluetooth/hci/aclpacketconsts.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_LINKMGR);

#endif

#ifdef _DEBUG

PANICCATEGORY("proxysap");

#endif

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

//diagnostics this will be NULL.

const char* const KBT_PROXYSAP_NAME_DIAG = __PLATSEC_DIAGNOSTIC_STRING("Bluetooth Proxy SAP");

CBTProxySAP::CBTProxySAP(CPhysicalLinksManager& aLinksMan, CPhysicalLink* aPhysicalLink)

: CBTBasebandSAP(aLinksMan, aPhysicalLink),

  iRequestedLinkPolicy(EHoldMode | ESniffMode | EParkMode, ETrue),

  iNotifiedUp(EFalse), iTerminating(ENone), iBasebandNotifyOptions(0),

  iEventNotificationQueue(_FOFF(TBTQueuedBasebandEventNotification, iLink)),

  iEventNotificationStatus(EDisabled)

	{

	LOG1(_L("Creating proxy SAP 0x%08x"), this);

#ifdef PROXY_COMMUNICATES

	iHandle = KHCIBroadcastHandle;

#endif

	}

CBTProxySAP* CBTProxySAP::NewLC(CPhysicalLinksManager& aConnectionMan, CPhysicalLink* aPhysicalSAP)

	{

	CBTProxySAP* s = new(ELeave) CBTProxySAP(aConnectionMan, aPhysicalSAP);

	CleanupStack::PushL(s);

	s->ConstructL();

	return s;

	}

CBTProxySAP* CBTProxySAP::NewL(CPhysicalLinksManager& aConnectionMan, CPhysicalLink* aPhysicalSAP)

	{

	CBTProxySAP* s = CBTProxySAP::NewLC(aConnectionMan, aPhysicalSAP);

	CleanupStack::Pop(s);

	return s;

	}

void CBTProxySAP::ConstructL()

	{

	CBTBasebandSAP::ConstructL();

	iAsyncCallback = new(ELeave) CAsyncCallBack(CActive::EPriorityStandard);

	if(iPhysicalLink)

		{

		User::LeaveIfError(iPhysicalLink->SubscribeProxySAP(*this));

		}

	// now we need to go async and check whether the physical link is up

	// has to be async because we don't have a socket at the moment

	AsyncCheckLinkUp();

	}

void CBTProxySAP::ClearPhysicalLink()

	{

	if (iPhysicalLink)

		{

		iPhysicalLink->UnsubscribeProxySAP(*this);

		iPhysicalLink = NULL;

		}

	}

CBTProxySAP::~CBTProxySAP()

	{

	LOG1(_L("Deleting proxy SAP 0x%08x"), this);

	// If iTerminating is set we are waiting for iLinksMan to call us back 

	// which means that it holds a pointer to this ProxySAP

	if (iTerminating!=ENone)

		{

		__ASSERT_DEBUG(EFalse, Panic(EBTProxySAPBadCanClose));

		iLinksMan.ClearTerminatingProxy(this);

		}

	ClearPhysicalLink();

	/*Remove this proxy SAP from the PLM queue*/

	iPLMLink.Deque();

	delete iAsyncCallback;

 	delete iRawConduit;

	}

// from SAP - the proxy will not do all of these

void CBTProxySAP::Start()

	{

	// do nothing

	}

void CBTProxySAP::RemName(TSockAddr& aAddr) const

	{

	// our name is the same is that of the PHY, assuming it is connected

	// note esock doesn't allow a great deal of maneouvour on errors here!

	if(iPhysicalLink && iPhysicalLink->IsConnected())

		{

		TBTSockAddr bbAddr(aAddr);

		bbAddr.SetBTAddr(iPhysicalLink->BDAddr());

		aAddr=bbAddr;   // Convert back

		}

	}

TInt CBTProxySAP::SetRemName(TSockAddr& aAddr)

	{

	TBTSockAddr addr = TBTSockAddr::Cast(aAddr);

	iRemoteDev = addr.BTAddr();

	// we now know our remote address so should try to get a PHY if there

	CPhysicalLink *link = iLinksMan.FindPhysicalLink(iRemoteDev);

	// If we're (re-)using the same physical link, there's no

	// reason to subscribe again

	if (link != iPhysicalLink)

		{

		// Unsubscribe from old link

		if (iPhysicalLink)

			{

			iPhysicalLink->UnsubscribeProxySAP(*this);

			}

		iPhysicalLink = link;

		// Subscribe to new one

		if (iPhysicalLink)

			{

			return iPhysicalLink->SubscribeProxySAP(*this);

			}

		}

	// in any case return no error since the BAP may try to create PHY

	return KErrNone;

	}

TInt CBTProxySAP::GetOption(TUint aLevel,TUint aName,TDes8& aOption) const

	{

	TInt rerr = KErrNone;

	if(aLevel != KSolBtLMProxy)

		{

		rerr = KErrNotSupported;

		}

	switch (aName)

		{

		case EBBEnumeratePhysicalLinks:

			iLinksMan.EnumeratePhysicalLinks(aOption);

			break;

		case EBBGetPhysicalLinkState:

			{

			if (aOption.Length() != sizeof(TBTBasebandEventNotification))

				return KErrArgument;

			if (!iPhysicalLink)

				{

				LOG1(_L("GetOption called on non-existent Phy ....so return %d (KErrDisconnected)"), KErrDisconnected);

				return KErrDisconnected;

				}

			TBTBasebandEventNotification basebandState;

			iPhysicalLink->GetCurrentBasebandState(basebandState);

			TBTBasebandEvent pkcgEvent(basebandState);

			aOption = pkcgEvent;

			}

			break;

		default:

			rerr = KErrArgument;

			break;

		}

	return rerr;

	}

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

	{

	if (aLevel == KSolBtLMProxy)

		{

		switch(aName)

			{

			case KLMReadRssiIoctl:

			case KLMReadLinkQualityIoctl:

			case KLMReadFailedContactCounterIoctl:

			case KLMReadCurrentTransmitPowerLevelIoctl:

				{

				if (!aOption || aOption->Length() != sizeof(TInt))

					{

					IoctlComplete(KErrArgument, aLevel, aName);

					break;

					}

				// Add the current request to a queue; pass this pointer to  call IoctlComplete()

				// when result is available from the controller. Multiple SAPs can queue data on

				// the same physical link.

				TPckgBuf<TInt> currentValuePckg;

				currentValuePckg.Copy(*aOption);

				if(iPhysicalLink)

					{

					iPhysicalLink->ReadNewPhysicalLinkMetricValue(aName, *this, currentValuePckg());

					}

				else

					{

					IoctlComplete(KErrDisconnected, KSolBtLMProxy, aName, NULL);

					}

				break;

				}

			case KLMBasebandEventOneShotNotificationIoctl:

				{

				ASSERT_DEBUG(iEventNotificationStatus == EDisabled);

				iEventNotificationStatus = EEnabledOneShot;

				const TBTBasebandEventNotification* option = reinterpret_cast<const TBTBasebandEventNotification*>(aOption->Ptr());

				__ASSERT_DEBUG(option->EventType(), Panic(EBTProxySAPInvalidEventMask));

				SetBasebandNotificationOptions(option->EventType());

				}

				break;

			case KLMBasebandEventNotificationIoctl:

				{

				ASSERT_DEBUG(iEventNotificationStatus != EEnabledOneShot);

				const TBTBasebandEventNotification* option = reinterpret_cast<const TBTBasebandEventNotification*>(aOption->Ptr());

				SetBasebandNotificationOptions(option->EventType());

				if(iEventNotificationStatus == EDisabled)

					{

					// Send an initial event describing the current state of the

					// baseband link.

					TBTBasebandEventNotification basebandState;

					if (!iPhysicalLink)

						{

						LOG1(_L("Ioctl called on non-existent Phy ....so indicate %d (KErrDisconnected)"), KErrDisconnected);

						SetNullBasebandState(basebandState);

						TBTBasebandEvent pkcgEvent(basebandState);

						IoctlComplete(KErrNone, KSolBtLMProxy, KLMBasebandEventNotificationIoctl, &pkcgEvent);

						}

					else

						{

						iPhysicalLink->GetCurrentBasebandState(basebandState);

						TBTBasebandEvent pkcgEvent(basebandState);

						IoctlComplete(KErrNone, KSolBtLMProxy, KLMBasebandEventNotificationIoctl, &pkcgEvent);

						}

					iEventNotificationStatus = EEnabledQueuing;

					}

				else

					{

					// Check if anything is currently in the queue.

					iEventNotificationStatus = EEnabledCanSend;

					if(!iEventNotificationQueue.IsEmpty())

						{

						TBTQueuedBasebandEventNotification* e = iEventNotificationQueue.First();

						iEventNotificationQueue.Remove(*e);

						TBTBasebandEventNotification event(e->EventType() & iBasebandNotifyOptions, e->ErrorCode());

						delete e;

						if(event.EventType())

							{

							TBTBasebandEvent pkcgEvent(event);

							IoctlComplete(KErrNone, KSolBtLMProxy, KLMBasebandEventNotificationIoctl, &pkcgEvent);

							iEventNotificationStatus = EEnabledQueuing;

							}

						}

					}

				}

				break;

			default:

				{

 				IoctlComplete(KErrNotSupported, aLevel, aName);

   				break;

 				}

			};

		}

	else

		{

		IoctlComplete(KErrNotSupported, aLevel, aName);

		}

	}

void CBTProxySAP::IoctlComplete(TInt aErr, TUint /*aLevel*/, TUint /*aName*/, TDesC8* aBuf)

 	{

 	if (iSocket)

 		{

 		if (aErr==KErrNone)

 			{

 			iSocket->IoctlComplete(aBuf);

 			}

 		else 

 			{	

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

 			}

   		}

   	}

void CBTProxySAP::SetNullBasebandState(TBTBasebandEventNotification & aEvent)

	{

	// Populate the event with no physical link baseband state.

	TUint32 events = 0;

	events |= ENotifyPhysicalLinkDown;

	aEvent.SetEventType(events);

	aEvent.SetErrorCode(0);

	}

void CBTProxySAP::CancelIoctl(TUint aLevel,TUint aName)

	{

 	__ASSERT_DEBUG((aLevel == KSolBtLMProxy), Panic(EBTProxySAPInvalidIoctl));

	if (aLevel == KSolBtLMProxy)

		{

		switch(aName)

			{

			case KLMBasebandEventNotificationIoctl:

				SetBasebandNotificationOptions(0);	

				iEventNotificationStatus = EDisabled;

				ClearBasebandEventQueue();

				break;

			case KLMBasebandEventOneShotNotificationIoctl:

				SetBasebandNotificationOptions(0);	

				iEventNotificationStatus = EDisabled;

				ClearBasebandEventQueue();

				break;

			case KLMReadRssiIoctl:

			case KLMReadLinkQualityIoctl:

			case KLMReadFailedContactCounterIoctl:

			case KLMReadCurrentTransmitPowerLevelIoctl:

				iPLMLink.Deque();

				break;

			default:

				__ASSERT_DEBUG(EFalse, Panic(EBTProxySAPInvalidIoctl));

				break;

			};

		}

	}

void CBTProxySAP::ClearBasebandEventQueue()

	{

	TSglQueIter<TBTQueuedBasebandEventNotification> iter(iEventNotificationQueue);

	while (iter)

		{

		TBTQueuedBasebandEventNotification* e = iter++;

		iEventNotificationQueue.Remove(*e);

		delete e;

		}

	}

void CBTProxySAP::SetBasebandNotificationOptions(TUint32 aOption) 

	{

	iBasebandNotifyOptions = aOption;

	}

TInt CBTProxySAP::SAPSetOption(TUint aLevel,TUint aName, const TDesC8 &aOption)

	{

	LOG3(_L("SetOpt %d, %d on proxy SAP 0x%08x"), aLevel, aName, this);

	TInt rerr = KErrNone;

	// Arbitration will be required after most operations.

	TBool arbitrate = ETrue;

	TBool immediateArbitration = EFalse;

	TBool localPriority = EFalse;

	if(aLevel != KSolBtLMProxy)

		{

		rerr = KErrNotSupported;

		}

	if(!iPhysicalLink && 

		aName!=EBBSubscribePhysicalLink)

		{

		rerr = KErrDisconnected;

		}

	if(rerr == KErrNone)

		{

		switch (aName)

			{

			case EBBSubscribePhysicalLink:

				{

				// Make sure we're not already subscribed

				if (iPhysicalLink)

					{

					__ASSERT_DEBUG(EFalse,Panic(EBTProxySAPAlreadySubscribed));

					rerr = KErrArgument;

					break;

					}			

				TPckgBuf<TBTDevAddr> pckg;

				pckg.Copy(aOption);

				// try to find a PHY from addr, and if successful subscribe to it

				iPhysicalLink = iLinksMan.FindPhysicalLink(pckg());

				if (iPhysicalLink)

					{

					rerr = iPhysicalLink->SubscribeProxySAP(*this);

					if(rerr == KErrNone)

						{

						iRemoteDev = pckg();

						}

					}

				else

					{

					LOG1(_L("Proxy SAP 0x%08x -- couldn't find physical link"), this);

					LOG(_L("Looking for addr: "));

					LOGBTDEVADDR(pckg());

					iLinksMan.DumpPhysicalLinks();

					rerr = KErrDisconnected;

					}

				arbitrate = EFalse;

				}

				break;

			case EBBBeginRaw:

				//EBBBeginRaw requires 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, KBT_PROXYSAP_NAME_DIAG);

				if (rerr != KErrNone)

					{

				    break;

				    }											

				if(!(iPhysicalLink && iPhysicalLink->Handle()!=KHCIBroadcastHandle))

				//if no existing, connected PHY, try to find a random PHY which is

					{

					// We don't support this option if we're subscribed to the broadcast handle

					if (iPhysicalLink)

						{

						__ASSERT_DEBUG(EFalse,Panic(EBTProxySAPSubscribedToBroadcastHandle));

						rerr = KErrArgument;

						break;

						}

					iPhysicalLink = iLinksMan.FindPhysicalLink();

					if (iPhysicalLink)

						{

						rerr = iPhysicalLink->SubscribeProxySAP(*this);

						if(rerr == KErrNone)

							{

							iRemoteDev = iPhysicalLink->BDAddr();

							}

						}

					else

						{

						rerr = KErrDisconnected;

						}

					}

				if(rerr == KErrNone)

					{

					rerr = CreateRawConduit();

					}

				arbitrate = EFalse;

				break;

			case EBBCancelModeRequest:

				rerr = SetModeRequested(EActiveMode);

				break;

			case EBBRequestSniff:

				rerr = SetModeRequested(ESniffMode);

				localPriority = ETrue;

				break;

			// clients cannot ask for Hold

			case EBBRequestPark:

				rerr = SetModeRequested(EParkMode);

				localPriority = ETrue;

				break;

			case EBBRequestRoleMaster:

				if(iRequestedLinkPolicy.IsSwitchAllowed() && iPhysicalLink->IsRoleSwitchSupported())

					{

					rerr = iPhysicalLink->RequestChangeRole(EMaster);

					arbitrate = EFalse;

					}

				else

					{

					rerr = KErrNotSupported;

					}

				break;

			case EBBRequestRoleSlave:

				if(iLinksMan.LinkManagerProtocol().IsRoleSwitchSupportedLocally() && 

					iRequestedLinkPolicy.IsSwitchAllowed() && iPhysicalLink->IsRoleSwitchSupported())

					{

					rerr = iPhysicalLink->RequestChangeRole(ESlave);

					arbitrate = EFalse;

					}

				else

					{

					rerr = KErrNotSupported;

					}

				break;

			case EBBRequestPreventRoleChange:

				iRequestedLinkPolicy.SetSwitchAllowed(EFalse);

				break;

			case EBBRequestAllowRoleChange:

				iRequestedLinkPolicy.SetSwitchAllowed(ETrue);

				break;

			case EBBRequestChangeSupportedPacketTypes:

				{