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

// Name        : 6to4_flow.cpp

// Part of     : 6to4 plugin / 6to4.prt

// Implements 6to4 automatic and configured tunnels, see

// RFC 3056 & RFC 2893

// Version     : 0.2

//

// INCLUDE FILES

#include <in_chk.h>

#include "6to4_flow.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ==============================

// ============================ MEMBER FUNCTIONS ==============================

// ----------------------------------------------------------------------------

// C6to4FlowInfo::C6to4FlowInfo

// ----------------------------------------------------------------------------

C6to4FlowInfo::C6to4FlowInfo(const TPacketHead &aHead)

	: iInterfaceIndex(aHead.iInterfaceIndex)

	{

	// Need to save the inner selector information which is

	// restored at ReadyL.

	iSrcPort = aHead.iSrcPort;

	iDstPort = aHead.iDstPort;

	iIcmpType = aHead.iIcmpType;

	iIcmpCode = aHead.iIcmpCode;

	iInnerIp = aHead.ip6;

	iDstId = aHead.iDstId;

	iSrcId = aHead.iSrcId;

	}

// ----------------------------------------------------------------------------

// C6to4FlowInfo::~C6to4FlowInfo

// ----------------------------------------------------------------------------

C6to4FlowInfo::~C6to4FlowInfo ()

	{

	iPacket.Free();

	}

// ----------------------------------------------------------------------------

// 6to4FlowInfo::ReadyL

// The stack asks if the flow is ready to send. In the same time, the plugin

// configures the source IP address from the flow, including configuring it to

// the virtual interface. Set the packet source and destination IP addresses

// for the inner (IPv6) header. Set the packet interface index. Set the packet 

// next header to be the inner header next header and set the packet IP version

// to 6.

// ----------------------------------------------------------------------------

//

TInt C6to4FlowInfo::ReadyL (TPacketHead & aHead)

	{

	// Save the fixed packet content from the TPacketHead

	iOffset = aHead.iOffset;

	iPacket.Free();

	if (iOffset > 0)

		{

		iPacket.Assign(aHead.iPacket);

		aHead.iOffset = 0;

		}

	// Save the outer IP information

	iOuterIp = aHead.ip6;

	// Set inner header source and dest addresses

	aHead.ip6 = iInnerIp;

	// Inner Version() is not yet set correctly, make it correct.

	aHead.ip6.SetVersion(iInnerIp.DstAddr().IsV4Mapped() ? 4 : 6);

	aHead.iSrcId = iSrcId;

	aHead.iDstId = iDstId;

	aHead.iInterfaceIndex = iInterfaceIndex;

	// Both next header and iProtocol must have the same value

	// as the iPacket is now empty.

	aHead.iProtocol = (TUint8)iInnerIp.NextHeader();

	aHead.iSrcPort = iSrcPort;

	aHead.iDstPort = iDstPort;

	aHead.iIcmpType = iIcmpType;

	aHead.iIcmpCode = iIcmpCode;

	return EFlow_READY;

	}

// ----------------------------------------------------------------------------

// 6to4FlowInfo::ApplyL

// Final stage where the 6to4 touches the outgoing packet. Space is made for

// the IP header and the IP header is initialized.

// ----------------------------------------------------------------------------

TInt C6to4FlowInfo::ApplyL (RMBufSendPacket & aPacket, RMBufSendInfo & aInfo)

	{

	// Apply the tunnelling

	// Prepend the fixed content (if any) below the IP header

	if (iOffset > 0)

		{

		RMBufChain work;

		// Note: assumed that if CopyL leaves, then work is empty

		iPacket.CopyL(work);

		aPacket.Prepend(work);

		aInfo.iLength += iOffset;

		}

	switch(iOuterIp.Version())

		{

		case 6:

			{

			aPacket.PrependL(sizeof(TInet6HeaderIP));

			aInfo.iLength += sizeof(TInet6HeaderIP);

			aInfo.iProtocol = KProtocolInet6Ip;

			TInet6Packet<TInet6HeaderIP> ip(aPacket);

			if (ip.iHdr == NULL)

				User::Leave(KErrGeneral);

			// Build outer IPv6 header (already in iOuterIp, just copy)

			*ip.iHdr = iOuterIp;

			// Note: Certain packets must not have ECN ECT bits set. tcp_sap.cpp sets

			// KIpNoEcnEct for those packets.

			if (aInfo.iFlags & KIpNoEcnEct)

				{

				ip.iHdr->SetTrafficClass(ip.iHdr->TrafficClass() & 0xfc);

				}

			ip.iHdr->SetPayloadLength(aInfo.iLength);

			break;

			}

		case 4:

			{

			// Make space for IPv4 header

			aPacket.PrependL (20);

			aInfo.iLength += 20;

			aInfo.iProtocol = KProtocolInetIp;

			TInet6Checksum < TInet6HeaderIP4 > ip (aPacket);

			if (ip.iHdr == NULL)

				User::Leave (KErrGeneral);

			// Build the outer IPv4 header

			ip.iHdr->Init(iOuterIp.TrafficClass() & ((aInfo.iFlags & KIpNoEcnEct) ? 0xfc : 0xff));

			// Raw Address load. Someone else must have already checked that

			// both src and dst are IPv4 mapped addresses at the end of the

			// ReadyL phase! This just does a blind copy.

			ip.iHdr->DstAddrRef() = iOuterIp.DstAddr().u.iAddr32[3];

			ip.iHdr->SrcAddrRef() = iOuterIp.SrcAddr().u.iAddr32[3];

			// Somewhat ad hoc thing: if DontFragment flag is set, then

			// set the DF bit to the IPv4 header...

			if (aInfo.iFlags & KIpDontFragment)

				ip.iHdr->SetFlags((TUint8)(ip.iHdr->Flags() | KInet4IP_DF));

			ip.iHdr->SetHeaderLength (20);

			ip.iHdr->SetTotalLength (aInfo.iLength);

			ip.iHdr->SetTtl(iOuterIp.HopLimit());

			// NOTE!!! Something might be done for this. Now it is theoretically

			// possible that a same host receives protocol 41 packets from us and

			// we have two or more flows with protocol 41 AND two packets get 

			// fragmented and are reassembled in the same time by the remote host

			// AND the IPv4 identifier happens to be the same. That would break the

			// reassembly process, but since this is practically "impossible", it is

			// left now without a fix.

			ip.iHdr->SetIdentification (iPacketID++);                                                                

			ip.iHdr->SetProtocol (iOuterIp.NextHeader());

			// Checksum of the outer header.

			ip.ComputeChecksum ();

			break;

			}

		default:

			User::Leave(KErrGeneral);

		}

	// Pass the packet

	return 0;

	}

// ----------------------------------------------------------------------------

// 6to4FlowInfo::Open

// Open the flow, keep reference count.

// ----------------------------------------------------------------------------

//

void C6to4FlowInfo::Open ()

	{

	iRefs++;

	}

// ----------------------------------------------------------------------------

// 6to4FlowInfo::Close

// Close the flow if the reference count has reached zero. Remove the flow 

// from any list it is stored.

// ----------------------------------------------------------------------------

//

void C6to4FlowInfo::Close ()

	{

	if (--iRefs < 0)

		{

		delete this;

		}

	}

// ========================== OTHER EXPORTED FUNCTIONS ========================

//  End of File