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

#include "qoslib_glob.h"

#include "qoslib.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <networking/qoslib_internal.h>

#endif

//lint -e{708} does not like union initializers

const TIp6Addr KInet6AddrMask = {{{0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,

								0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}}};

//

CChannel::CChannel(CQoSMan* aManager)

	{

	iManager = aManager;

	iPending = ENone;

	iCapabilities = 0;

	iObserver = NULL;

	iChannelId = -1;

	iStatus = EInit;

	}

CChannel::~CChannel()

	{

	iManager->RemoveQoSChannel(this);

	}

CChannel* CChannel::NewL(CQoSMan* aManager, RSocket& aSocket, 

	CQoSParameters* aSpec)

	{

	CChannel* channel = new (ELeave) CChannel(aManager);

	CleanupStack::PushL(channel);

	channel->ConstructL(aSocket, aSpec);

	CleanupStack::Pop();

	return channel;

	}

void CChannel::ConstructL(RSocket& aSocket, CQoSParameters* aSpec)

	{

	if (aSpec)

		{

		iPolicy.CopyL(*aSpec);

		}

	TInt ret = iRequestSelector.SetAddr(aSocket);

	if (ret != KErrNone)

		{

		User::Leave(ret);

		}

	}

TInt CChannel::Close()

	{

	CRequest* request=NULL;

	TRAPD(err, request = CRequest::NewL(NULL, KQoSDefaultBufSize));

	if (err == KErrNone)

		{

		request->iMsg->Init(EPfqosDeleteChannel);

		request->iMsg->AddChannel(iChannelId);

		iPending = EPendingDelete;

		iManager->Send(request);

		}

	return err;

	}

void CChannel::ProcessEvent(TPfqosMessage& aMsg)

	{

	iCapabilities = aMsg.iEvent.iExt->event_value;

	switch (aMsg.iEvent.iExt->event_type)

		{

		case KPfqosEventFailure:

			if (iStatus == EChannelCreated)

				{

				iStatus = EInit;

				}

			if (iObserver && (iEventMask & EQoSEventFailure))

				{

				ParseExtensions(aMsg, iPolicy);

				CQoSFailureEvent event(iPolicy, 

					aMsg.iBase.iMsg->pfqos_msg_errno);

				iObserver->Event(event);

				}

			break;

		case KPfqosEventConfirm:

			if (iStatus == EChannelCreated)

				{

				iStatus = EChannelReady;

				}

			if (iObserver && iEventMask & EQoSEventConfirm)

				{

				ParseExtensions(aMsg, iPolicy);

				CQoSConfirmEvent event(iPolicy);

				iObserver->Event(event);

				}

			break;

		case KPfqosEventAdapt:

			if (iStatus == EChannelCreated)

				{

				iStatus = EChannelReady;

				}

			if (iObserver && iEventMask & EQoSEventAdapt)

				{

				ParseExtensions(aMsg, iPolicy);

				CQoSAdaptEvent event(iPolicy, 

					aMsg.iBase.iMsg->pfqos_msg_errno);

				iObserver->Event(event);

				}

			break;

		case KPfqosEventJoin:

			if (iObserver && iEventMask & EQoSEventJoin)

				{

				TInt reason = aMsg.iBase.iMsg->pfqos_msg_errno;

				TQoSSelector sel;

				CreateSelector(sel, aMsg);

				CQoSJoinEvent event(sel, reason);

				iObserver->Event(event);

				}

			break;

		case KPfqosEventLeave:

			if (iObserver && iEventMask & EQoSEventLeave)

				{

				TInt reason = aMsg.iBase.iMsg->pfqos_msg_errno;

				TQoSSelector sel;

				CreateSelector(sel, aMsg);

				CQoSLeaveEvent event(sel, reason);

				iObserver->Event(event);

				}

			break;

		default:

			return;

		}

	}

void CChannel::ProcessReply(TPfqosMessage& aMsg)

	{

	TInt aErrorCode = aMsg.iBase.iMsg->pfqos_msg_errno;

	if (aErrorCode)

		{

		NotifyError(aErrorCode);

		}

	else

		{

		switch (iPending)

			{

			case EPendingOpenExisting:

				iPending = ENone;

				iChannelId = aMsg.iChannel.iExt->channel_id;

				// mmm

				iStatus = EChannelReady;

				// mmm

				if (iObserver && iEventMask & EQoSEventChannel)

					{

					ParseExtensions(aMsg, iPolicy);

					CQoSChannelEvent event(&iPolicy, KErrNone);

					iObserver->Event(event);

					}

				break;

			case EPendingOpenExistingSetQoS:

				iChannelId = aMsg.iChannel.iExt->channel_id;

				iStatus = EChannelCreated;

				if (iObserver && iEventMask & EQoSEventChannel)

					{

					CQoSChannelEvent event(NULL, KErrNone);

					iObserver->Event(event);

					}

				TRAPD(err, iManager->SetQoSL(*this));

				//lint -e{961} does not like missing final 'else'

				if (err == KErrNone)

					{

					iPending = EPendingSetPolicy;

					}

				else if (iObserver && iEventMask & EQoSEventFailure)

					{

					CQoSFailureEvent event(iPolicy, err);

					iObserver->Event(event);

					}

				break;

			case EPendingOpen:

				{

				_LIT(KText1, "CChannel::ProcessReply");

				__ASSERT_ALWAYS((aMsg.iChannel.iExt != NULL), 

					User::Panic(KText1, 0));

				iPending = ENone;

				iChannelId = aMsg.iChannel.iExt->channel_id;

				iStatus = EChannelCreated;

				}

				break;

			case EPendingDelete:

				delete this;

				break;

			case EPendingSetPolicy:

			case EPendingJoin:

			case EPendingLeave:

			default:

				iPending = ENone;

				break;

			}

		}

	}

TBool CChannel::Match(TInt aChannelId)

	{

	if (aChannelId >= 0 && aChannelId == iChannelId)

		{

		return ETrue;

		}

	return EFalse;

	}

TBool CChannel::MatchReply(const TPfqosMessage& aMsg, TUint8 aMsgType)

	{

	//lint -e{961} does not like missing final 'else'

	if (((iPending == EPendingOpenExisting && 

		  aMsgType == EPfqosOpenExistingChannel) ||

		 (iPending == EPendingOpenExistingSetQoS && 

		  aMsgType == EPfqosOpenExistingChannel) ||

		 (iPending == EPendingOpen && aMsgType == EPfqosCreateChannel) ||

		 (iPending == EPendingJoin && aMsgType == EPfqosJoin) || 

		 (iPending == EPendingLeave && aMsgType == EPfqosLeave)) && 

		 (iRequestSelector.GetDst().Match(*aMsg.iDstAddr.iAddr)) &&

		 (iRequestSelector.GetSrc().Match(*aMsg.iSrcAddr.iAddr)) &&

		 (iRequestSelector.Protocol() == aMsg.iSelector.iExt->protocol) &&

		 (iRequestSelector.GetDst().Port() == aMsg.iDstAddr.iAddr->Port()) &&

		 (iRequestSelector.GetSrc().Port() == aMsg.iSrcAddr.iAddr->Port()) &&

		 (iRequestSelector.MaxPortDst() == 

		  aMsg.iDstAddr.iExt->pfqos_port_max) &&

		 (iRequestSelector.MaxPortSrc() == 

		  aMsg.iSrcAddr.iExt->pfqos_port_max))

		 {

		return ETrue;

		}

	else if (((iPending == EPendingDelete && 

			   aMsgType == EPfqosDeleteChannel) ||

			  (iPending == EPendingSetPolicy && 

			   aMsgType == EPfqosConfigChannel))// ||

		   && (iChannelId == aMsg.iChannel.iExt->channel_id))

		{

		return ETrue;

		}

	return EFalse;

	}

TInt CChannel::OpenExisting()

	{

	TRAPD(err, iManager->OpenExistingL(*this, iRequestSelector));

	if (err == KErrNone)

		{

		iPending = EPendingOpenExisting;

		}

	return err;

	}

TInt CChannel::SetQoS(CQoSParameters& aPolicy)

	{

	if (iPending)

		{

		if (iPending == EPendingOpenExisting)

			{

			TRAPD(err, iPolicy.CopyL(aPolicy));

			if (err == KErrNone)

				{

				iPending = EPendingOpenExistingSetQoS;

				}

			return err;

			}

		else

			{

			return KErrInUse;

			}

		}

	TRAPD(err, iPolicy.CopyL(aPolicy));

	if (err != KErrNone)

		{

		return err;

		}

	if (iStatus == EInit)

		{

		TRAP(err, iManager->CreateL(*this, iRequestSelector));

		if (err == KErrNone)

			{

			iPending = EPendingOpen;

			}

		}

	else

		{

		TRAP(err, iManager->SetQoSL(*this));

		if (err == KErrNone)

			{

			iPending = EPendingSetPolicy;

			}

		}

	return err;

	}

TInt CChannel::Join(RSocket& aSocket)

	{

	if (iStatus != EChannelReady)

		{

		return KErrNotReady;

		}

	if (iPending != ENone)

		{

		return KErrInUse;

		}

	TInt err = iRequestSelector.SetAddr(aSocket);

	if (err != KErrNone)

		{

		return err;

		}

	TRAP(err, iManager->JoinL(*this, iRequestSelector));

	if (err == KErrNone)

		{

		iPending = EPendingJoin;

		}

	return err;

	}

TInt CChannel::Leave(RSocket& aSocket)

	{

	if (iStatus != EChannelReady)

		{

		return KErrNotReady;

		}

	if (iPending != ENone)

		{

		return KErrInUse;

		}

	TInt err = iRequestSelector.SetAddr(aSocket);

	if (err != KErrNone)

		{

		return err;

		}

	TRAP(err, iManager->LeaveL(*this, iRequestSelector));

	if (err == KErrNone)

		{

		iPending = EPendingLeave;

		}

	return err;

	}

TInt CChannel::GetCapabilities(TUint& aCapabilities)

	{

	aCapabilities = iCapabilities;

	return KErrNone;

	}

void CChannel::NotifyError(TInt aReason)

	{

	TPendingStatus status = iPending;

	iPending = ENone;

	if (aReason)

		{

		switch (status)

			{

			case EPendingSetPolicy:

				if (iObserver && iEventMask & EQoSEventFailure)

					{

					CQoSFailureEvent event(iPolicy, aReason);

					iObserver->Event(event);

					}

				break;

			case EPendingOpen:

				if (iObserver && iEventMask & EQoSEventFailure)

					{

					CQoSFailureEvent event(iPolicy, aReason);

					iObserver->Event(event);

					}

				break;

			case EPendingJoin:

				if (iObserver && iEventMask & EQoSEventJoin)

					{

					CQoSJoinEvent event(iRequestSelector, aReason);

					iObserver->Event(event);

					}

				break;

			case EPendingLeave:

				if (iObserver && iEventMask & EQoSEventLeave)

					{

					CQoSLeaveEvent event(iRequestSelector, aReason);

					iObserver->Event(event);

					}

				break;

			case EPendingOpenExisting:

				if (iObserver && iEventMask & EQoSEventChannel)

					{

					CQoSChannelEvent event(NULL, aReason);

					iObserver->Event(event);

					}

				break;

			case EPendingOpenExistingSetQoS:

				TRAPD(err, iManager->CreateL(*this, iRequestSelector));

				//lint -e{961} does not like missing final 'else'

				if (err == KErrNone)

					{

					iPending = EPendingOpen;

					}

				else if (iObserver && iEventMask & EQoSEventFailure)

					{

					CQoSFailureEvent event(iPolicy, err);

					iObserver->Event(event);

					}

				break;

			default:

				break;

			}

		}

	}

void CChannel::CreateSelector(TQoSSelector& aSelector, 

	const TPfqosMessage& aMsg)

	{

	TInetAddr src;

	TInetAddr srcmask;

	src = *aMsg.iSrcAddr.iAddr;

	src.SetFamily(KAFUnspec);

	src.SetAddress(KInet6AddrNone);

	srcmask.SetAddress(KInet6AddrMask);

	aSelector.SetAddr(src, 

			  srcmask, 

			  *aMsg.iDstAddr.iAddr, 

			  *aMsg.iDstAddr.iPrefix, 

			  aMsg.iSelector.iExt->protocol, 

			  aMsg.iSrcAddr.iExt->pfqos_port_max,

			  aMsg.iDstAddr.iExt->pfqos_port_max);

	aSelector.SetIapId(aMsg.iSelector.iExt->iap_id);

	}