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

// in_flow.cpp - stack side of the general part of the flow

//

#include <es_mbuf.h>

#include "in_flow.h"

#include "inet6log.h"

#include "iface.h"

static const TUint16 KNoFrag = 0xFFFF;

//

//	TFlowHook

//

class TFlowHook

	{

public:

	TFlowHook(MFlowHook &aHook, TInt aFrag) : iHook(aHook), iFrag(aFrag < 0 ? KNoFrag : (TUint16)aFrag) {}

	MFlowHook &iHook;			//< The Flow Hook

	const TUint16 iFrag;		//< The header size before OpenL (or 0xFFFF, if no fragmenting)

	TUint16 iMtu;				//< The Fragmenting MTU (only if iFrag != 0xFFFF)

	};

CFlowInternalContext::~CFlowInternalContext()

	{

	RemoveHooks();

	}

//	**********************

//	CFlowContext::AddHookL

//	**********************

//	aHook must never be NULL!

//

void CFlowInternalContext::AddHookL(MFlowHook *aHook, TInt aFrag)

	{

	//

	// Allow call with NULL aHook, does nothing then...

	//

	if (!aHook)

		return;

	//

	// iHookList is created only if actual hooks are required

	//

	if (iHookList == NULL)

		iHookList = new (ELeave) CArrayFixFlat<TFlowHook>(4);

	TFlowHook h(*aHook, aFrag);

	iHookList->AppendL(h);

	aHook->Open();

	}

//	*************************

//	CFlowContext::RemoveHooks

//	*************************

//

void CFlowInternalContext::RemoveHooks()

	{

	//

	// Remove hooks

	//

	if (iHookList)

		{

		for (TInt i = iHookList->Count(); i > 0; )

			{

			const TFlowHook &h = iHookList->At(--i);

			h.iHook.Close();

			}

		delete iHookList;

		iHookList = NULL;

		}

	}

//	*******************

//	CFlowContext::Start

//	*******************

//	Must be called once when the flow Open/Hook adding has

//	been completed, but before calling the hook Ready methods

//

void CFlowInternalContext::Start()

	{

	__ASSERT_DEBUG(iHead.iPacket.IsEmpty(), User::Panic(_L("iHead.iPacket not empty"), 0));

	iStart = iHead;					// Just save a copy of the iHead.

	iStart.iOffset = iHdrSize;		// Borrow the iOffset field to hold the initial header overhead

	}

//	*******************

//	CFlowContext::Reset

//	*******************

//	Can be called any time to set the flow into initial state

//	(called before hook Ready method calls)

//

void CFlowInternalContext::Reset()

	{

	iHead.iPacket.Free();

	iHead = iStart;

	//

	// Reset the initial (after Open-phase) header overhead

	//

	iHdrSize = iHead.iOffset;

	iHead.iOffset = 0;

	}

//

//	CFlowContext::RefreshHooks

//	**************************

//	(Utility for derived classes)

//	Call the Ready() methods of the registered hooks

//	and check if all of them are ready. If so, the state

//	of the flow will be EFlow_READY, otherwise the state

//	will be the state of the first hook that reports

//	not READY.

//

void CFlowInternalContext::RefreshHooks()

	{

	TInt err;

	iStatus = EFlow_READY;

	if (iHookList)

		{

		LOG(const MFlowHook *tmp = NULL);

		TRAP(err,

			for (TInt i = iHookList->Count(); iStatus == EFlow_READY && i > 0; )

				{

				TFlowHook &h = iHookList->At(--i);

				iStatus = h.iHook.ReadyL(iHead);

				LOG(tmp = &h.iHook);

				// Compute fragmenting MTU, if fragmenting is requested

				// (result is garbage if iFrag == KNoFrag, but it does not matter)

				h.iMtu = (TUint16)(PathMtu() - HeaderSize() - h.iFrag);

				}

			); // TRAP

		if (err != KErrNone)

			{

			LOG(Log::Printf(_L("\tMFlowHook[%u] ReadyL LEAVE WITH err=%d"), (TInt)tmp, err));

			// *NOTE*

			//		Must ensure that the status will be negative,

			//		because positive values are interpreted as

			//		"pending" signals and a later wakeup is

			//		expected. It is doubtful that a hook leaves

			//		unexpectedly and still has set for the wakeup!

			//		... though, I suppose this should never

			//		happen? Leave errors are always negative?

			//		-- msa

			//	Force KErrGeneral, if err is not negative!

			iStatus = err < 0 ? err : KErrGeneral;

			}

		LOG(if (iStatus != EFlow_READY) Log::Printf(_L("\tMFlowHook[%u] ReadyL iStatus = %d"), (TInt)tmp, iStatus));

		}

	}

//	CFlowInternalContext::ApplyHooksL

// **********************************

TInt CFlowInternalContext::ApplyHooksL(RMBufSendPacket &aPacket, RMBufSendInfo &aInfo)

	{

	const TInt n = iHookList->Count();

	for (TInt i = 0; i < n; )

		{

		const TFlowHook &h = iHookList->At(i++);

		if (h.iFrag != KNoFrag && aInfo.iLength > h.iMtu)

			return --i;

		const TInt ret = h.iHook.ApplyL(aPacket, aInfo);

		if (ret > 0)

			{

			LOG(Log::Printf(_L("\tMFlowHook[%u] ApplyL returns %d, restarat ApplyL (*deprecated feature used*)"), (TInt)&h.iHook, ret));

			i = 0;			// Restart hooks.

			}

		else if (ret < 0)

			{

			LOG(Log::Printf(_L("\tMFlowHook[%u] ApplyL returns %d, packet thrown away"), (TInt)&h.iHook, ret));

			User::Leave(ret);

			}

		else if (iHookList == NULL)

			{

			// Returned KErrNone, but the iHookList has disappeared

			LOG(Log::Printf(_L("\tMFlowHook[%u] ApplyL disconnected the flow"), (TInt)&h.iHook));

			User::Leave(KErrDisconnected);

			}

		}

	return n;

	}

void CFlowInternalContext::ApplyHooksFragmentedL(TInt aStart, RMBufSendPacket &aPacket)

	{

	RMBufSendInfo *info = aPacket.Unpack();

	const TInt n = iHookList->Count();

	for (TInt i = aStart; i < n; )

		{

		const TFlowHook &h = iHookList->At(i++);

		const TInt ret = h.iHook.ApplyL(aPacket, *info);

		if (ret > 0)

			{

			LOG(Log::Printf(_L("\tMFlowHook[%u] ApplyL (fragment) returns %d, restart ApplyL (*deprecated feature used*)"), (TInt)&h.iHook, ret));

			i = 0;			// Restart hooks.

			}

		else if (ret < 0)

			{

			LOG(Log::Printf(_L("\tMFlowHook[%u] ApplyL (fragment) returns %d"), (TInt)&h.iHook, ret));

			User::Leave(ret);

			}

		else if (iHookList == NULL)

			{

			// Returned KErrNone, but the iHookList has disappeared

			LOG(Log::Printf(_L("\tMFlowHook[%u] ApplyL (fragment) disconnected the flow"), (TInt)&h.iHook));

			User::Leave(KErrDisconnected);

			}

		}

	aPacket.Pack();

	}

//

//	CFlowContext::ApplyHooks

//	************************

//	Apply hooks on flow to the packet. This has only two possible

//	returns

//

//	== KErrNone	- hooks applied successfully

//	!= KErrNone - error occurred, packet has been released	

//

TInt CFlowInternalContext::ApplyHooks(RMBufSendPacket &aPacket, RMBufSendInfo &aInfo, RMBufPktQ &aFragments, MNetworkServiceExtension &aExt)

	{

	TInt ret = KErrNone;

	if (iHookList)

		{

		TInt n = 0;

		TRAPD(err, n = ApplyHooksL(aPacket, aInfo));

		if (err != KErrNone)

			{

			// The ApplyL has left, free packet!

			LOG(Log::Printf(_L("\tApplyHooks (ApplyL) dropping packet with reason %d"), err));

			if (!aPacket.IsEmpty())

				{

				LOG(Log::Printf(_L("\tApplyHooks (ApplyL) packet is not empty, closing flow reference")));

				aInfo.iFlow.Close();

				}

			aPacket.Free();

			return err;

			}

		if (n < iHookList->Count())

			{

			// Packet too long for MTU and hook wants fragmenting

			// done before it.

			RMBufPktQ fragments;

			if (aExt.Fragment(aPacket, aInfo, iHookList->At(n).iMtu, fragments))

				{

				TRAP(err,

					while (fragments.Remove(aPacket))

						{

						ApplyHooksFragmentedL(n, aPacket);

						aFragments.Append(aPacket);

						}

						);

				ret = err;

				}

			aFragments.Append(fragments); // Just in case some was left there...

			LOG(if (ret != KErrNone) Log::Printf(_L("\tApplyHooks (ApplyL fragments) returning %d"), err));

			return ret;

			}

		}

	if (aInfo.iLength > PathMtu() && !aExt.Fragment(aPacket, aInfo, PathMtu(), aFragments))

		{

		// Fragmentation required, but failed for some reason. The loopback ICMP has already been sent,

		// Just return something != KErrNone for the caller to indicate that the aPacket has been

		// processed (and should be empty at this point). 

		ret = KErrNotSupported;

		}

	return ret;

	}