// 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_tunnel.cpp

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

// Implements 6to4 automatic and configured tunnels, see

// RFC 3056 & RFC 2893

// Version     : 0.2

//

// INCLUDE FILES

#include "6to4_tunnel.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// TInetAddress6Only

// A simple help class which overrides the Input method and

// guarantees that the result is always KAfInet6 on valid

// input.

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

class TInetAddr6Only : public TInetAddr

	{

	public:

	TInt Input(const TDesC &aBuf);

	};

TInt TInetAddr6Only::Input(const TDesC &aBuf)

	{

	const TInt ret = TInetAddr::Input(aBuf);

	if (ret == KErrNone && Family() == KAfInet)

		ConvertToV4Mapped();

	return ret;

	}

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

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

// CTunnel::CTunnel

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CTunnel::CTunnel ()

	{

	}

// Destructor

CTunnel::~CTunnel ()

	{

	delete iName;

	}

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

// CTunnel::SetNameL

// Sets a name for the tunnel.

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

//

void CTunnel::SetNameL (const TDesC & aName)

	{

	delete iName;

	iName = NULL;

	iName = HBufC::NewMaxL (aName.Length ());

	*iName = aName;

	}

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

// TTunnelParser::TTunnelParser

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

TTunnelParser::TTunnelParser () : iToken(), iTokenVal(0), iTunnelQueue()

	{

	iTunnelQueue.SetOffset (_FOFF (CTunnel, iDLink));

	}

// Destructor

TTunnelParser::~TTunnelParser ()

	{

	CTunnel *tunnel = NULL;

	TTunnelQueueIter iter (iTunnelQueue);

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

		{

		tunnel->iDLink.Deque();

		delete tunnel;

		}

	}

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

// TTunnelParser::ParseL

// Parses the tunnel configuration file and creates tunnel objects accordingly.

//

// File syntax example. 

// Keywords: tunnels, tunnel, endpoint_address, virtual_if_address,

//           route_address, route_prefix_length, STRING, INTEGER.

// #

// # Write comments like this to the beginning of the file

// #

//

// tunnels = {

//	 tunnel_1,

//	 tunnel_2,

//	 tunnel_3

//	}

//

// tunnel tunnel_1 = {

//	 STRING endpoint_address = 192.168.0.3,

//	 STRING virtual_if_address = 2000:abcd::1,

//	 STRING route_address = 2000:abcd::,

//	 INTEGER route_prefix_length = 32

// }

//

// tunnel tunnel_2 = {

// 	 STRING endpoint_address = 192.168.0.3,

//   STRING virtual_if_address = 2000:1111::1,	

//	 STRING route_address = 2000:1111::,

//	 INTEGER route_prefix_length = 32

// }

//

// tunnel tunnel_3 = {

//	 STRING endpoint_address = 192.168.0.5,

//   STRING virtual_if_address = 2000:2222::1,

//	 STRING route_address = 2000:2222::,

// 	 INTEGER route_prefix_length = 32

// }

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

//

TInt TTunnelParser::ParseL (const TDesC & aTunnelData)

	{

	Assign (aTunnelData);

	// Parse the list of tunnels first and create and add them to the list.

	TTokenType token;

	while ((token = NextToken()) == ETokenTypeComment)

		{

				// Intentionally left blank

		}

	if (token == ETokenTypeString)

		{

		if (iToken.Compare (_L ("tunnels")) != 0)

			{

			return KErrGeneral;

			}

		}

	else

		{

		return token == ETokenTypeEof ? KErrNone : KErrGeneral;

		}

	if ((token = NextToken ()) != ETokenTypeEqual)

		{

		return KErrGeneral;

		}

	if ((token = NextToken ()) != ETokenTypeBraceLeft)

		{

		return KErrGeneral;

		}

	do

		{

		token = NextToken ();

		if (token == ETokenTypeBraceRight)

			{

			// Tunnels done

			break;

			}

		if (token == ETokenTypeString)

			{

			CTunnel *tunnel = new (ELeave) CTunnel;

			tunnel->SetNameL (iToken);

			iTunnelQueue.AddLast (*tunnel);

			}

		else

			{

			return KErrGeneral;

			}

		}

	while ((token = NextToken ()) == ETokenTypeComma);

	if (token != ETokenTypeBraceRight)

		{

		return KErrGeneral;

		}

	// Parse individual tunnels. Search for the list for a match and if

	// found, add parameters there.

	while ((token = NextToken ()) == ETokenTypeString)

		{

		if (iToken.Compare (_L ("tunnel")) != 0)

			{

			return KErrGeneral;

			}

		TInetAddr6Only address;

		CTunnel *tunnel = NULL;

		if ((token = NextToken ()) == ETokenTypeString)

			{

			TTunnelQueueIter iter (iTunnelQueue);

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

				{

				if (tunnel->Name().Compare (iToken) == 0)

					{

					// found.

					break;

					}

				}

			if (tunnel == NULL)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeEqual)

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeBraceLeft)

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			if (iToken.Compare (_L ("STRING")) != 0)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			if (iToken.Compare (_L ("endpoint_address")) != 0)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeEqual)

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			// Parse endpoint address

			if (address.Input (iToken) != KErrNone)

				{

				return KErrGeneral;

				}

			tunnel->EndpointAddr().SetAddress (address.Ip6Address(), address.Scope());

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeComma)

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			if (iToken.Compare (_L ("STRING")) != 0)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			if (iToken.Compare (_L ("virtual_if_address")) != 0)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeEqual)

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			// Parse inner virtual address

			if (address.Input (iToken) != KErrNone)

				{

				return KErrGeneral;

				}

			tunnel->VirtualIfAddr().SetAddress(address.Ip6Address(), address.Scope());

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeComma)

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			if (iToken.Compare (_L ("STRING")) != 0)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			if (iToken.Compare (_L ("route_address")) != 0)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeEqual)

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			// Parse route prefix as "address"

			if (address.Input (iToken) != KErrNone)

				{

				return KErrGeneral;

				}

			tunnel->RouteAddr() = address.Ip6Address();

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeComma)

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			if (iToken.Compare (_L ("INTEGER")) != 0)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) == ETokenTypeString)

			{

			if (iToken.Compare (_L ("route_prefix_length")) != 0)

				{

				return KErrGeneral;

				}

			}

		else

			{

			return KErrGeneral;

			}

		if ((token = NextToken ()) != ETokenTypeEqual)

			{

			return KErrGeneral;

			}

		if (Val (iTokenVal) != KErrNone)

			return KErrGeneral;

		tunnel->SetRoutePrefixLength(iTokenVal);

		if ((token = NextToken ()) != ETokenTypeBraceRight)

			{

			return KErrGeneral;

			}

		}

	// Scan through the list and make sure all tunnels have been configured.

	TTunnelQueueIter iter (iTunnelQueue);

	CTunnel *tunnel = NULL;

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

		{

		if (tunnel->EndpointAddr().IsUnspecified ())

			{

			// not configured.

			return KErrGeneral;

			}

		}

	return KErrNone;

	}

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

// TTunnelParser::NextToken

// Returns the next token type in the input stream. iToken gets the value of 

// the (string) token.

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

//

TTunnelParser::TTokenType TTunnelParser::NextToken ()

	{

	TChar ch;

	TTokenType val;

	SkipSpaceAndMark ();

	if (Eos ())

		val = ETokenTypeEof;

	else

		{

		ch = Get ();

		switch (ch)

			{

			case '{':

				val = ETokenTypeBraceLeft;

				break;

			case '}':

				val = ETokenTypeBraceRight;

				break;

			case '(':

				val = ETokenTypeParLeft;

				break;

			case ')':

				val = ETokenTypeParRight;

				break;

			case '=':

				val = ETokenTypeEqual;

				break;

			case ',':

				val = ETokenTypeComma;

				break;

				case '#':

						val = ETokenTypeComment;

						while (!Eos())

						{

								ch = Get();

								if (ch == '\n' || ch == '\r')

										break;

						}

						break;

			default:

				// Integers, ip addresses, etc. are mapped to strings.

				val = ETokenTypeString;

				while (!Eos ())

					{

					ch = Peek ();

					if (ch == '{' || ch == '}' ||

						ch == '(' || ch == ')' ||

						ch == '=' || ch == '#' ||

						ch == ',' || ch.IsSpace ())

						break;

					Inc ();

					}

			}

		}

	iToken.Set (MarkedToken ());

	SkipSpaceAndMark ();

	return val;

	}

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

//  End of File