// 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:

//

#include <f32file.h>

#include <es_ini.h>

#include "qosliblog.h"

#include "qoslib.h"

#include "pfqosparser.h"

#include "pfqos.h"

#include "qos_ini.h"

#include "qoslib_glob.h"

#include "pfqos_stream.h"

//

// DLL entry point

//

GLDEF_C TInt E32Dll()

	{

	return(KErrNone);

	}

//

CRequest* CRequest::NewL(CQoSRequestBase* aOwner, TUint aBufSize)

	{

	CRequest* request = new (ELeave) CRequest(aOwner);

	CleanupStack::PushL(request);

	request->ConstructL(aBufSize);

	CleanupStack::Pop();

	return request;

	}

CRequest::~CRequest()

	{

	delete iMsg;

	}

CRequest::CRequest(CQoSRequestBase* aOwner) : iOwner(aOwner)

	{

	iMsg = NULL;

	}

void CRequest::ConstructL(TUint aBufSize)

	{

	iMsg = CPfqosStream::NewL(aBufSize);

	};

//

class CSender : public CActive

	{

	public:

	static CSender* NewL(CQoSMan* aManager, TInt aPriority=EPriorityStandard);

	~CSender();

	void Send(CRequest* aRequest);

	void ClearPendingRequest(CQoSRequestBase* aRequest);

	protected:

	CSender(CQoSMan* aManager, TInt aPriority);

	void ConstructL();

	void RunL();

	void DoCancel();

	private:

	CQoSMan* iManager;

	CRequest* iCurrentRequest;

	TSglQue<CRequest> iRequests;

	};

CSender* CSender::NewL(CQoSMan* aManager, TInt aPriority)

	{

	CSender* sender = new (ELeave) CSender(aManager, aPriority);

	CleanupStack::PushL(sender);

	sender->ConstructL();

	CleanupStack::Pop();

	return sender;

	}

CSender::CSender(CQoSMan* aManager, TInt aPriority) : CActive(aPriority), iManager(aManager)

	{

	CActiveScheduler::Add(this);

	iRequests.SetOffset(_FOFF(CRequest, iLink));

	iCurrentRequest=NULL;

	}

void CSender::ConstructL()

	{

	}

CSender::~CSender()

	{

	if (IsActive())

		Cancel();

	delete iCurrentRequest;

	while (!iRequests.IsEmpty())

		{

		CRequest* request = iRequests.First();

		iRequests.Remove(*request);

		delete request;

		}

	iRequests.Reset();

	}

void CSender::Send(CRequest* aRequest)

	{

	if (IsActive())

		iRequests.AddLast(*aRequest);

	else

		{

		iCurrentRequest = aRequest;

		iCurrentRequest->iMsg->Send(iManager->Socket(), iStatus);

		SetActive();

		}

	}

void CSender::ClearPendingRequest(CQoSRequestBase* aRequest)

	{

	if (iCurrentRequest != NULL)

		{

		if (iCurrentRequest->iOwner == aRequest)

			iCurrentRequest->iOwner = NULL;

		}

	}

void CSender::RunL()

	{

	TInt err = iStatus.Int();

	if (err && iCurrentRequest->iOwner)

		iCurrentRequest->iOwner->NotifyError(err);

	delete iCurrentRequest;

	iCurrentRequest = NULL;

	if (!iRequests.IsEmpty())

		{

		CRequest* request = iRequests.First();

		iRequests.Remove(*request);

		iCurrentRequest = request;

		iCurrentRequest->iMsg->Send(iManager->Socket(), iStatus);

		SetActive();

		}

	}

void CSender::DoCancel()

	{

	iManager->Socket().CancelWrite();

	}

//

CQoSMan* CQoSMan::NewL(TInt aPriority)

	{

	CQoSMan* manager;

	manager = QoSManGlobals::Get();

	if (!manager)

		{

		manager = new (ELeave) CQoSMan(aPriority);

		CleanupStack::PushL(manager);

		manager->ConstructL();

		CleanupStack::Pop();

		QoSManGlobals::Set(manager);

		}

	manager->Open();

	return manager;

	}

void CQoSMan::ConstructL()

	{

	_LIT(KDescPfqos, "pfqos");

	User::LeaveIfError(iSocketServer.Connect());

	User::LeaveIfError(iSocket.Open(iSocketServer, KDescPfqos));

	iSender = CSender::NewL(this);

	iBuf = HBufC8::NewL(KQoSDefaultBufSize);

	TPtr8 tmp(iBuf->Des());

	iRecBuf.Set(tmp);

	iUid.Set(RProcess().Type());

	iSocket.Recv(iRecBuf, 0, iStatus);

	SetActive();

	}

CQoSMan::CQoSMan(TInt aPriority) : CActive(aPriority), iRecBuf(0,0)

	{

	CActiveScheduler::Add(this);

	iRefCount = 0;

	iChannels.SetOffset(_FOFF(CChannel, iNext));

	iStaticPolicies.SetOffset(_FOFF(CPolicy,iNext));

	iNotifyPending = EFalse;

	iShutdown = EFalse;

	}

void CQoSMan::Close()

	{

	if (--iRefCount <= 0)

		{

		if (iNotifyPending)

			iShutdown = ETrue;

		else

			delete this;

		}

	}

CQoSMan::~CQoSMan()

	{

	while (!iChannels.IsEmpty())

		{

		CChannel* channel = iChannels.First();

		iChannels.Remove(*channel);

		delete channel;

		}

	iChannels.Reset();

	while (!iStaticPolicies.IsEmpty())

		{

		CPolicy* policy = iStaticPolicies.First();

		iStaticPolicies.Remove(*policy);

		delete policy;

		}

	iStaticPolicies.Reset();

	delete iSender;

	if (IsActive())

		Cancel();

	iSocket.Close();

	iSocketServer.Close();

	delete iBuf;

	QoSManGlobals::Set(NULL);

	}

CChannel* CQoSMan::OpenQoSChannelL(RSocket& aSocket)

	{

	CChannel* channel = CChannel::NewL(this, aSocket, NULL);

	iChannels.AddLast(*channel);

	return channel;

	}

void CQoSMan::RemoveQoSChannel(CChannel* aChannel)

	{

	TSglQueIter<CChannel> iter(iChannels);

	CChannel* channel;

	while ((channel = iter++) != NULL)

		{

		if (channel == aChannel)

			{

			iChannels.Remove(*aChannel);

			break;

			}

		}

	}

void CQoSMan::SetQoSL(CChannel& aChannel)

	{

	CRequest* request = CRequest::NewL(&aChannel, KQoSDefaultBufSize);

	request->iMsg->Init(EPfqosConfigChannel);

	request->iMsg->AddQoSParameters(aChannel.GetPolicy().iQoS);

	request->iMsg->AddChannel(aChannel.ChannelId());

	TQoSExtensionQueueIter iter(aChannel.GetPolicy().Extensions());

	CExtensionBase *extension;

	while ((extension=iter++) != NULL)

		request->iMsg->AddExtensionPolicy(extension->Data());

	iSender->Send(request);

	}

void CQoSMan::CreateL(CChannel& aChannel, const TQoSSelector& aSelector)

	{

	CRequest* request = CRequest::NewL(&aChannel, KQoSDefaultBufSize);

	request->iMsg->Init(EPfqosCreateChannel);

	request->iMsg->AddSelector((TUint8)aSelector.Protocol(), iUid.UidType(), EPfqosFlowspecPolicy, aSelector.IapId(), EPfqosApplicationPriority, TPtr(0,0));

	request->iMsg->AddSrcAddress(aSelector.GetSrc(), aSelector.GetSrcMask(), (TUint16)aSelector.MaxPortSrc()); 

	request->iMsg->AddDstAddress(aSelector.GetDst(), aSelector.GetDstMask(), (TUint16)aSelector.MaxPortDst()); 

	request->iMsg->AddChannel(0);

	request->iMsg->AddQoSParameters(aChannel.GetPolicy().iQoS);

	TQoSExtensionQueueIter iter(aChannel.GetPolicy().Extensions());

	CExtensionBase *extension;

	while ((extension=iter++) != NULL)

		request->iMsg->AddExtensionPolicy(extension->Data());

	Send(request);

	}

void CQoSMan::OpenExistingL(CChannel& aChannel, const TQoSSelector& aSelector)

	{

	CRequest* request = CRequest::NewL(&aChannel, KQoSDefaultBufSize);

	request->iMsg->Init(EPfqosOpenExistingChannel);

	request->iMsg->AddSelector((TUint8)aSelector.Protocol(), iUid.UidType(), EPfqosFlowspecPolicy, aSelector.IapId(), EPfqosApplicationPriority, TPtr(0,0));

	request->iMsg->AddSrcAddress(aSelector.GetSrc(), aSelector.GetSrcMask(), (TUint16)aSelector.MaxPortSrc()); 

	request->iMsg->AddDstAddress(aSelector.GetDst(), aSelector.GetDstMask(), (TUint16)aSelector.MaxPortDst()); 

	request->iMsg->AddChannel(0);

	Send(request);

	}

void CQoSMan::JoinL(CChannel& aChannel, const TQoSSelector& aSelector)

	{

	CRequest* request = CRequest::NewL(&aChannel, KQoSDefaultBufSize);

	request->iMsg->Init(EPfqosJoin);

	request->iMsg->AddSelector((TUint8)aSelector.Protocol(), iUid.UidType(), EPfqosFlowspecPolicy, aSelector.IapId(), EPfqosApplicationPriority, TPtr(0,0));

	request->iMsg->AddSrcAddress(aSelector.GetSrc(), aSelector.GetSrcMask(), (TUint16)aSelector.MaxPortSrc()); 

	request->iMsg->AddDstAddress(aSelector.GetDst(), aSelector.GetDstMask(), (TUint16)aSelector.MaxPortDst()); 

	request->iMsg->AddChannel(aChannel.ChannelId());

	Send(request);

	}

void CQoSMan::LeaveL(CChannel& aChannel, const TQoSSelector& aSelector)

	{

	CRequest* request = CRequest::NewL(&aChannel, KQoSDefaultBufSize);

	request->iMsg->Init(EPfqosLeave);

	request->iMsg->AddSelector((TUint8)aSelector.Protocol(), iUid.UidType(), EPfqosFlowspecPolicy, aSelector.IapId(), EPfqosApplicationPriority, TPtr(0,0));

	request->iMsg->AddSrcAddress(aSelector.GetSrc(), aSelector.GetSrcMask(), (TUint16)aSelector.MaxPortSrc()); 

	request->iMsg->AddDstAddress(aSelector.GetDst(), aSelector.GetDstMask(), (TUint16)aSelector.MaxPortDst()); 

	request->iMsg->AddChannel(aChannel.ChannelId());

	Send(request);

	}

//

// Notify informs applications about events received from the kernel. 

// A callback function is called, if application has registered for the event.

// Selector is matched against flows to find out if an application ought to be notified.

//

void CQoSMan::Notify(TPfqosMessage& aMsg)

	{

	if (!aMsg.iBase.iMsg)

		return;

	switch (aMsg.iBase.iMsg->pfqos_msg_type)

		{

	case EPfqosEvent:

		ExecEvent(aMsg);

		return;

	case EPfqosFlush:

		// All policies have been deleted from the kernel. 

		// Inform applications with POLICY_EVENT_QOS_FAILURE.

		Flush();

		break;

	case EPfqosUpdate:

	case EPfqosDelete:

	case EPfqosAdd:

	case EPfqosGet:

	case EPfqosReject:

	case EPfqosDump:

	case EPfqosConfigure:

	case EPfqosJoin:

	case EPfqosLeave:

	case EPfqosCreateChannel:

	case EPfqosOpenExistingChannel:

	case EPfqosDeleteChannel:

	case EPfqosConfigChannel:

	case EPfqosLoadFile:

	case EPfqosUnloadFile:

		ExecReply(aMsg);

		break;

	default:

		break;

		}

	}

// Flush deletes all flowinfo in CQoSMan. If aEvent > 0, inform applications.

void CQoSMan::Flush()

	{

	while (!iStaticPolicies.IsEmpty())

		{

		CPolicy* policy = iStaticPolicies.First();

		if (policy)

			{

			iStaticPolicies.Remove(*policy);

			delete policy;

			}

		}

	iStaticPolicies.Reset();

	}

CChannel* CQoSMan::Match(TPfqosMessage& aMsg)

	{

	if (!aMsg.iChannel.iExt)

		return NULL;

	TSglQueIter<CChannel> iter(iChannels);

	CChannel* channel;

	while ((channel = iter++) != NULL)

		{

		if (channel->Match(aMsg.iChannel.iExt->channel_id))

			return channel;

		}

	return NULL;

	}

CChannel* CQoSMan::MatchChannelReply(TPfqosMessage& aMsg, TUint8 aMsgType)

	{

	if (aMsgType == EPfqosCreateChannel || aMsgType == EPfqosJoin || 

	aMsgType == EPfqosLeave)

	if (aMsg.iSrcAddr.iExt == NULL || aMsg.iDstAddr.iExt == NULL || aMsg.iSelector.iExt == NULL)

		return NULL;

	TSglQueIter<CChannel> iter(iChannels);

	CChannel* channel;

	while ((channel = iter++) != NULL)

		{

		if (channel->MatchReply(aMsg, aMsgType))

			return channel;

		}

	return NULL;

	}

CPolicy* CQoSMan::MatchPolicyReply(TPfqosMessage& aMsg, TUint8 aMsgType)

	{

	TSglQueIter<CPolicy> iter(iStaticPolicies);

	CPolicy* policy;

	while ((policy = iter++) != NULL)

		{

		if (policy->MatchReply(aMsg, aMsgType))

			return policy;

		}

	return NULL;

	}

//

// POLICY_EVENT message has to contain <header, selector, srcaddr, dstaddr, policy_event,(flowspec)>

// flowspec is mandatory for all others but POLICY_EVENT_QOS_FAILURE event.

//

void CQoSMan::ExecEvent(TPfqosMessage& aMsg)

	{

	if (aMsg.iEvent.iExt == NULL || aMsg.iFlowSpec.iExt == NULL)

		return;

	TUint event = aMsg.iEvent.iExt->event_type;

	switch (event)

		{

	case KPfqosEventReceivers:

	case KPfqosEventSenders:

		break;

	default:

		if (aMsg.iChannel.iExt)

			{

			TSglQueIter<CChannel> iter(iChannels);

			CChannel* channel;

			while ((channel = iter++) != NULL)

				{

				if (channel->Match(aMsg.iChannel.iExt->channel_id))

					channel->ProcessEvent(aMsg);

				}

			}

		else

			{

			if (aMsg.iSrcAddr.iExt == NULL || aMsg.iDstAddr.iExt == NULL || aMsg.iSelector.iExt == NULL)

				return;

			TSglQueIter<CPolicy> iter(iStaticPolicies);

			CPolicy* policy;

			while ((policy = iter++) != NULL)

				policy->ProcessEvent(aMsg);

			}

		break;

		}

	}

void CQoSMan::ExecReply(TPfqosMessage& aMsg)

	{

	TUint8 type = aMsg.iBase.iMsg->pfqos_msg_type;

	CChannel* request = MatchChannelReply(aMsg, type);

	if (request)

		request->ProcessReply(aMsg);

	else

		{

		if (aMsg.iSrcAddr.iExt == NULL || aMsg.iDstAddr.iExt == NULL || aMsg.iSelector.iExt == NULL)

			return;

		CPolicy* policy = MatchPolicyReply(aMsg, type);

		if (policy)

			policy->ProcessReply(aMsg);

		}

	}

void CQoSMan::RunL()

	{

	if (iStatus.Int() == KErrNone)

		{

		TPfqosMessage msg(iRecBuf);

		__ASSERT_DEBUG(msg.iError == KErrNone, User::Panic(_L("CQoSMan*::RunL(): Msg corrupted"),msg.iError));

		// Should log the error

		if (msg.iError == KErrNone)

			{

			iNotifyPending = ETrue;

			LOG(Log::Printf(_L("CQoSMan::RunL() - [%d] "),msg.iBase.iMsg->pfqos_msg_errno));

			Notify(msg);

			iNotifyPending = EFalse;

			}

		}

	if (!iShutdown)

		{

		iRecBuf.Zero();

		iSocket.Recv(iRecBuf, 0, iStatus);

		SetActive();

		}

	else

		delete this;

	}

void CQoSMan::DoCancel()