// Copyright (c) 2008-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:
// Bulk Bearer interface.
//



/**
 @file
 @internalComponent
*/

#include "bulkbearerinterface.h"

#include <remcon/remconbearerbulkinterface.h>
#include <remcon/bearersecurity.h>
#include <remcon/clientinfo.h>

#include "bulkserver.h"
#include "remconmessage.h"
#include "utils.h"

#include <bluetooth/logger.h>

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

#ifdef _DEBUG
PANICCATEGORY("bulkif");
#endif // _DEBUG

static TBool RemConAddrsMatch(const TRemConAddress& aFirstAddr, const TRemConAddress& aSecondAddr)
	{
	LOG_STATIC_FUNC
	LOG(_L("aFirstAddr = ..."));
	LOGHEXDESC(aFirstAddr.Addr());
	LOG(_L("aSecondAddr = ..."));
	LOGHEXDESC(aSecondAddr.Addr());
	return aFirstAddr == aSecondAddr;
	}

static TUint32 RemConAddrHash(const TRemConAddress& aAddr)
	{
	LOG_STATIC_FUNC
	TBuf8<sizeof(TUid) + TRemConAddress::KMaxAddrSize> buf;
	buf.Append(TPckgC<TUid>(aAddr.BearerUid()));
	buf.Append(aAddr.Addr());
	LOG(_L("Hashing aAddr ..."));
	LOGHEXDESC(buf);
	TUint32 hash = DefaultHash::Des8(buf);
	LOG1(_L("hash = 0x%08x"), hash);
	return hash;
	}

CBulkBearerInterface* CBulkBearerInterface::NewL(CRemConBulkServer& aServer, CBearerManager& aBearerManager)
	{
	LOG_STATIC_FUNC;
	CBulkBearerInterface* self = new(ELeave) CBulkBearerInterface(aServer, aBearerManager);
	CleanupStack::PushL(self);
	self->ConstructL(aBearerManager);
	CleanupStack::Pop(self);
	return self;
	}

CBulkBearerInterface::~CBulkBearerInterface()
	{
	LOG_FUNC;
	
	StopBearers();

	iAddressedClients.Close();	
	iBearerIfs.Close();
	}

CBulkBearerInterface::CBulkBearerInterface(CRemConBulkServer& aServer, CBearerManager& aBearerManager)
	: iAddressedClients(RemConAddrHash, RemConAddrsMatch)
	, iSecurityPoliciesIter(aBearerManager.BearerSecurityPolicies())
	, iServer(aServer)
	{
	LOG_FUNC;
	}

void CBulkBearerInterface::ConstructL(CBearerManager& aBearerManager)
	{
	LOG_FUNC;
	
	aBearerManager.BulkInterfacesL(iBearerIfs);
	if(iBearerIfs.Count() == 0)
		{
		LEAVEL(KErrNotSupported);
		}
	
	TInt err = KErrNone;
	TBool oneStarted = EFalse;
	for(TInt i=0; i<iBearerIfs.Count(); i++)
		{
		ASSERT_DEBUG(iBearerIfs[i].iIf);
		err = iBearerIfs[i].iIf->MrcbbiStartBulk(*this);
		// if we couldn't start bulk service this is of no
		// use to us.  Throw it in the bin.
		if(err)
			{
			iBearerIfs.Remove(i);
			i--;
			}
		else
			{
			oneStarted = ETrue;
			}
		}
	if(!oneStarted)
		{
		LEAVEL(KErrNotSupported);
		}
	
	// Don't store the bearer manager - the less we interact with it the better.
	}

void CBulkBearerInterface::StopBearers()
	{
	for(TInt i=0; i<iBearerIfs.Count(); i++)
		{
		iBearerIfs[i].iIf->MrcbbiStopBulk();
		}
	}

void CBulkBearerInterface::BulkClientAvailable(const TRemConClientId& aClient)
	{
	LOG_FUNC;
	ASSERT_DEBUG(aClient != KNullClientId);
	
	for(TInt i=0; i<iBearerIfs.Count(); i++)
		{
		ASSERT_DEBUG(iBearerIfs[i].iIf);
		iBearerIfs[i].iIf->MrcbbiBulkClientAvailable(aClient);
		}
	}

void CBulkBearerInterface::BulkClientRemoved(const TRemConClientId& aClient)
	{
	LOG_FUNC;
	ASSERT_DEBUG(aClient != KNullClientId);
	
	for(TInt i=0; i<iBearerIfs.Count(); i++)
		{
		ASSERT_DEBUG(iBearerIfs[i].iIf);
		iBearerIfs[i].iIf->MrcbbiBulkClientNotAvailable(aClient);
		}
	// Bearer has been notified so remove the bulk client from any addressing.
	// Apologses for the O(n!) code below...it's the only way we can do it
	// without allocating memory (and the size of the table shouldn't be big
	// enough to cause problems.)
	const TRemConClientId* val = NULL;
	do
		{
		THashMapIter<TRemConAddress, TRemConClientId> iter(iAddressedClients);
		val = iter.CurrentValue();
		do
			{
			if(val && *val == aClient)
				{
				const TRemConAddress* key = iter.CurrentKey();
				ASSERT_DEBUG(key);
				TRemConAddress addr = *key;
				iAddressedClients.Remove(addr);
				// modified the hash map so we must discard the current iterator.
				break;
				}
			}
		while(val = iter.NextValue(), val);
		}
	while(val);
	}

MRemConBearerBulkInterface* CBulkBearerInterface::BearerIf(TUid aBearerUid) const
	{
	LOG_FUNC;
	LOG1(_L8("\taBearerUid = 0x%08x"), aBearerUid);

	MRemConBearerBulkInterface* bearerIf = NULL;

	const TUint numBearerIfs = iBearerIfs.Count();
	for ( TUint ii = 0 ; ii < numBearerIfs ; ++ii )
		{
		if ( iBearerIfs[ii].iBearerUid == aBearerUid )
			{
			bearerIf = iBearerIfs[ii].iIf;
			break;
			}
		}

	LOG1(_L8("\tbearerIf = 0x%08x"), bearerIf);
	return bearerIf;
	}

TBool CBulkBearerInterface::CheckPolicy(TUid aBearerUid, const TClientInfo& aClientInfo)
	{
	LOG_FUNC;
	TBool ret = EFalse;
	iSecurityPoliciesIter.SetToFirst();
	TBearerSecurity* sec = NULL;
	while(sec = iSecurityPoliciesIter++, sec)
		{
		if(sec->BearerUid() == aBearerUid)
			{
			if(aClientInfo.Message().IsNull()) // already been complete, so we have to rely on a process handle
				{
				RProcess process;
				TInt err = process.Open(aClientInfo.ProcessId(), EOwnerThread);
				if(err == KErrNone)
					{
					ret = sec->SecurityPolicy().CheckPolicy(process);
					}
				// else we failed to open the handle...so we cannot do any more - fail check.
				process.Close();
				}
			else
				{
				ret = sec->SecurityPolicy().CheckPolicy(aClientInfo.Message());
				}
			break;
			}
		}
	LOG1(_L("\tret = %d"), ret);
	return ret;
	}


TInt CBulkBearerInterface::Send(CRemConMessage& aMsg)
	{
	LOG_FUNC;
	LOG3(_L8("\taMsg.Addr.BearerUid = 0x%08x, aMsg.InterfaceUid = 0x%08x, aMsg.OperationId = 0x%02x"), 
		aMsg.Addr().BearerUid(), aMsg.InterfaceUid(), aMsg.OperationId());

	MRemConBearerBulkInterface* const bearerIf = BearerIf(aMsg.Addr().BearerUid());
	// Unlike the control server, there is no connection oriented nature, and so 
	// the messages are all connectionless.  However these should all be in response
	// to a message (as only responses are currently supported).
	ASSERT_DEBUG(bearerIf);	

	TInt ret = KErrNone;

	switch ( aMsg.MsgType() )
		{
	case ERemConResponse:
		ret = bearerIf->MrcbbiSendResponse(aMsg.InterfaceUid(), 
			aMsg.OperationId(), 
			aMsg.TransactionId(),
			aMsg.OperationData(), 
			aMsg.Addr());
		if ( ret == KErrNone )
			{
			// On success, the bearer takes ownership of the message data.
			aMsg.OperationData().Assign(NULL);
			}
		break;
	case ERemConReject:
		{
		ASSERT_DEBUG(aMsg.OperationData().Length() == 0);
		bearerIf->MrcbbiSendReject(aMsg.InterfaceUid(), 
			aMsg.OperationId(), 
			aMsg.TransactionId(),
			aMsg.Addr());
		break;
		}
	default:
		DEBUG_PANIC_LINENUM; // the session protects us against this
		break;
		}

	LOG1(_L8("\tret = %d"), ret);
	return ret;
	}

TInt CBulkBearerInterface::MrcbboDoNewCommand(const TRemConAddress& aAddr)
	{
	LOG_FUNC;
	LOG1(_L8("\taAddr.BearerUid = 0x%08x"), aAddr.BearerUid());

	TRemConClientId clientId;
	TRAPD(err, clientId = iAddressedClients.FindL(aAddr));
	
	if(err == KErrNone)
		{
		TRAP(err, NewCommandL(aAddr, clientId));
		}

	LOG1(_L8("\terr = %d"), err);
	return err;
	}

TInt CBulkBearerInterface::MrcbboDoNewCommand(const TRemConAddress& aAddr, const TRemConClientId& aClient)
	{
	LOG_FUNC;
	LOG1(_L8("\taAddr.BearerUid = 0x%08x"), aAddr.BearerUid());
	LOG1(_L8("\taClient = 0x%08x"), aClient);

	TRAPD(err, NewCommandL(aAddr, aClient));

	LOG1(_L8("\terr = %d"), err);
	return err;
	}

void CBulkBearerInterface::NewCommandL(const TRemConAddress& aAddr, const TRemConClientId& aClient)
	{
	LOG_FUNC;
	LOG1(_L8("\taAddr.BearerUid = 0x%08x"), aAddr.BearerUid());
	LOG1(_L8("\taClient = 0x%08x"), aClient);

	// Get the calling bearer from aAddr and get the new command from it.
	MRemConBearerBulkInterface* const bearerIf = BearerIf(aAddr.BearerUid());
	ASSERT_DEBUG(bearerIf);
	TUid interfaceUid;
	TUint transactionId;
	TUint operationId;
	RBuf8 data;
	TRemConAddress addr;
	LEAVEIFERRORL(bearerIf->MrcbbiGetCommand(interfaceUid,
		transactionId, 
		operationId, 
		data, 
		addr));
	LOG3(_L8("\treceived command with interfaceUid [0x%08x], operationId 0x%02x, data.Length = %d"), 
		interfaceUid, operationId, data.Length());
	// We now own what's pointed to by 'data'.
	CleanupClosePushL(data);

	CRemConMessage* msg = CRemConMessage::NewL(
		aAddr,
		aClient,
		ERemConCommand,
		ERemConMessageDefault,
		interfaceUid,
		operationId,
		data,
		0, // session ID as yet unknown
		transactionId);
	// 'msg' now has a pointer to the memory pointed to by 'data', and owns 
	// it.
	CLEANUPSTACK_POP1(&data);
	// Give the new command to the server, which takes ownership of it. 
	iServer.NewCommand(*msg);
	}

TUint CBulkBearerInterface::MrcbboDoNewTransactionId()
	{
	LOG_FUNC;
	TUint newId = iRunningTransactionId;

	if ( iRunningTransactionId == KMaxTUint )
		{
		iRunningTransactionId = 0;
		}
	else
		{
		++iRunningTransactionId;
		}
	
	LOG1(_L8("CBulkBearerInterface::MrcbboDoNewTransactionId newId = %d"), newId);
	return newId;
	}

void CBulkBearerInterface::MrcbboDoCommandExpired(TUint aTransactionId)
	{
	LOG_FUNC;
	iServer.CommandExpired(aTransactionId);
	}

TInt CBulkBearerInterface::MrcbboDoSetAddressedClient(const TRemConAddress& aAddr, const TRemConClientId& aClient)
	{
	LOG_FUNC;
	return iAddressedClients.Insert(aAddr, aClient); // hash map should cover uniqueness
	}

TInt CBulkBearerInterface::MrcbboDoRemoveAddressing(const TRemConAddress& aAddr)
	{
	LOG_FUNC;
	return iAddressedClients.Remove(aAddr);
	}