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

/**
 @file
 @internalComponent
*/

#include "eirmanserver.h"
#include <e32base.h>
#include <bluetooth/logger.h>
#include <bluetooth/logger/components.h>
#include <bluetooth/eirmanshared.h>
#include "eirmansession.h"
#include "eirmanager.h"
#include "eirmanserversecuritypolicy.h"
#include "linkmgr.h"
#include "eirmanpanics.h"


#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_EIRMANAGER);
#endif

CEirManServer* CEirManServer::NewL(MHCICommandQueue& aCommandQueue, CLinkMgrProtocol& aLinkMgrProtocol)
	{
	LOG_STATIC_FUNC
	
	CEirManServer* self = new(ELeave) CEirManServer(aCommandQueue, aLinkMgrProtocol);
	CleanupStack::PushL(self);
	// StartL is where the kernel checks that there isn't already an instance 
	// of the same server running, so do it before ConstructL.
	self->StartL(KEirManServerName);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CEirManServer::~CEirManServer()
	{
	LOG_FUNC
	delete iEirManager;
	}

CEirManServer::CEirManServer(MHCICommandQueue& aCommandQueue, CLinkMgrProtocol& aLinkMgrProtocol)
	: CPolicyServer(CActive::EPriorityStandard, KEirManServerPolicy)
	, iCommandQueue(aCommandQueue)
	, iLinkMgrProtocol(aLinkMgrProtocol)
	, iInternalSessionCount(0)
	, iExternalSessionCount(0)
	, iIsFeaturesReady(EFalse)
	, iIsEirSupported(EFalse)
	, iSessions(_FOFF(CEirManSession, iLink))
	{
	LOG_FUNC
	}

void CEirManServer::ConstructL()
	{
	LOG_FUNC
	}

CSession2* CEirManServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const
	{
	LOG_FUNC
	// Server will refuse to create any more session if we have found out eir isn't supported.
	if(iIsFeaturesReady && !iIsEirSupported)
		{
		User::Leave(KErrNotSupported);
		}
	
	LOG3(_L("CEirManServer::NewSessionL aVersion = (%d,%d,%d)"), aVersion.iMajor, aVersion.iMinor, aVersion.iBuild);
	
	// Version number check...
	TVersion v(KEirManSrvMajorVersionNumber,
			   KEirManSrvMinorVersionNumber,
			   KEirManSrvBuildVersionNumber);
	
	if ( !User::QueryVersionSupported(v, aVersion) )
		{
		LEAVEIFERRORL(KErrNotSupported);
		}
	
	CEirManServer* ncThis = const_cast<CEirManServer*>(this);
	
	CEirManExternalSession* sess = CEirManExternalSession::NewL(*ncThis);
	LOG1(_L("\tsess = 0x%08x"), sess);
	return sess;
	}

CEirManInternalSession* CEirManServer::NewInternalSessionL(MEirInternalSessionNotifier& aParent)
	{
	LOG_FUNC
	// Server will refuse to create any more session if we have found out eir isn't supported.
	if(iIsFeaturesReady && !iIsEirSupported)
		{
		User::Leave(KErrNotSupported);
		}
	CEirManInternalSession* sess = CEirManInternalSession::NewL(*this, aParent);
	return sess;
	}

void CEirManServer::AddSession(CEirManSession& aSession, TBool aInternalSession)
	{
	LOG_FUNC
	
	iSessions.AddLast(aSession);
	
	if (aInternalSession)
		{
		if(iInternalSessionCount++ == 0)
			{
			// While we have clients we need to make sure that the protocol remains alive.
			iLinkMgrProtocol.LocalOpen();
			}
		}
	else
		{
		if(iExternalSessionCount++ == 0)
			{
			// While we have clients we need to make sure that the protocol remains alive.
			iLinkMgrProtocol.Open();
			}
		}
	}

void CEirManServer::DropSession(TBool aInternalSession)
	{
	LOG_FUNC
	if (aInternalSession)
		{
		if(--iInternalSessionCount == 0)
			{
			iLinkMgrProtocol.LocalClose();
			}
		}
	else
		{
		if(--iExternalSessionCount == 0)
			{
			iLinkMgrProtocol.Close();
			}		
		}
	}

void CEirManServer::NotifyFeaturesReady()
	{
	if(iIsFeaturesReady == EFalse)
		{
		__ASSERT_DEBUG(!iEirManager, EIR_SERVER_PANIC(EEirServerEirMangerAlreadyExists));
		TRAPD(err, iEirManager = CEirManager::NewL(iCommandQueue, iLinkMgrProtocol));
		iIsFeaturesReady = ETrue;
		
		TDblQueIter<CEirManSession> sessionIter(iSessions);
		
		sessionIter.SetToFirst();
		CEirManSession* sessionPtr;
		if(iLinkMgrProtocol.IsExtendedInquiryResponseSupportedLocally() && err == KErrNone)
			{
			iIsEirSupported = ETrue;
			}
		else
			{
			err = ((err != KErrNone) ? KErrNoMemory : KErrNotSupported);
			}
		
		while((sessionPtr = sessionIter++) != NULL)
			{
			sessionPtr->NotifyEirFeatureState(err);
			}
		}
	}

TEirFeatureState CEirManServer::EirFeatureState()
	{
	TEirFeatureState ret = EEirFeaturePending;
	if(iIsFeaturesReady && iIsEirSupported)
		{
		ret = EEirFeatureReady;
		}
	else if(iIsFeaturesReady && !iIsEirSupported)
		{
		ret = EEirFeatureNotSupported;
		}
	else
		{
		// ret will still be EEirFeaturePending
		}
	return ret;
	}

CPolicyServer::TCustomResult CEirManServer::CustomSecurityCheckL(const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)
	{
	TEirManMessages function = static_cast<TEirManMessages>(aMsg.Function());
	TEirTag tag;
	TCustomResult result = EFail; //Fail everything by default
	_LIT_SECURITY_POLICY_S0(KSDPSecurityPolicy, KSDPServerID);
	_LIT_SECURITY_POLICY_S0(KStackSecurityPolicy, KStackID);
	_LIT_SECURITY_POLICY_C1(KVendorSpecificDataSecurityPolicy, ECapabilityWriteDeviceData);
	_LIT_SECURITY_POLICY_C1(KEirCommonSecurityPolicy, ECapabilityLocalServices);

	if(KEirCommonSecurityPolicy.CheckPolicy(aMsg))
		{
		if(function == EEirManRegisterTag)
			{
			tag = static_cast<TEirTag>(aMsg.Int0());
			switch(tag)
				{
				case EEirTagName:
				case EEirTagTxPowerLevel:
					/** These must have come from the stack **/
					if(KStackSecurityPolicy.CheckPolicy(aMsg))
						{
						result = EPass;
						}
					break;
				case EEirTagSdpUuid16:
				case EEirTagSdpUuid32:
				case EEirTagSdpUuid128:
					/** These must have come from SDP server **/
					if(KSDPSecurityPolicy.CheckPolicy(aMsg))
						{
						result = EPass;
						}
					break;
				case EEirTagManufacturerSpecific:
					/** To do this you must have write device data **/
					if(KVendorSpecificDataSecurityPolicy.CheckPolicy(aMsg))
						{
						result = EPass;
						}
					break;
				case EEirTagFlags:
					/** At present no implementation of Flags is supported. 
					So we are rejecting this until an implementation is provided. **/
				default: //unknown or reserved tag, reject
					//no need to do anything 
					break;
				}
			}
		}
	//Anything not covered by the above is invalid so do nothing and let it fail
	if(result == EFail)
		{
		LOG1(_L("CEirManServer::CustomSecurityCheckL failed. Function: %d"), function);
		}
	return result;
	}