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

// engine.cpp - IP administration tool engine

//

#include <eikenv.h>

#include "ipadm.h"

#include "engine.h"

#include "uniload.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <in_sock_internal.h>

#endif

#ifndef __SECURE_DATA__

#define DEFAULT_ROUTES_FILE	_L("C:\\Data\\IpAdm\\route.ini")

#else

#define DEFAULT_ROUTES_FILE	_L("route.ini")

#endif

LOCAL_C void AppendInterfaceStatus(TDes& buf, const TInt aStatus)

	{

	switch (aStatus)

		{

		case EIfPending:	buf.Append(_L("PEND ")); break;

		case EIfUp:			break;

		case EIfBusy:		buf.Append(_L("BUSY ")); break;

		case EIfDown:		buf.Append(_L("DOWN ")); break;

		default:			buf.Append(_L("???? ")); break;

		}

	}

LOCAL_C void AppendInterfaceName(TDes& buf, const TName& aName)

	{

	if (aName.Length() > 0)

		{

		buf.Append(aName);

		}

	else

		{

		buf.Append(_L("default"));

		}

	}

LOCAL_C void AppendRouteType(TDes& buf, const TInt aType)

	{

	switch (aType)

		{

		case ERtNormal:		buf.Append(_L(" ")); break;

		case ERtUser:		buf.Append(_L("u ")); break;

		case ERtIcmpAdd:	buf.Append(_L("- ")); break; // for IPv6, this is ND entry

		case ERtIcmpDel:	buf.Append(_L("d ")); break;

		default:			buf.Append(_L("? ")); break;

		}

	}

LOCAL_C void AppendRouteState(TDes& buf, const TInt aState)

	{

	switch (aState)

		{

		case ERtNone:		buf.Append(_L("NONE ")); break;

		case ERtPending:	buf.Append(_L("PEND ")); break;

		case ERtBusy:		buf.Append(_L("BUSY ")); break;

		case ERtReady:		break;

		case ERtDown:		buf.Append(_L("DOWN ")); break;

		default:			buf.Append(_L("???? ")); break;

		}

	}

//

//

// Just count the number of rightmost zeroes in an IPv6 address

// and return (128 - count).

//

LOCAL_C TInt MaskLength(const TIp6Addr &aAddr)

	{

	TInt count = 0;

	for (TInt i = sizeof(aAddr.u.iAddr8) / sizeof(aAddr.u.iAddr8[0]); --i >= 0; )

		{

		if (aAddr.u.iAddr8[i])

			{

			TUint8 nonZeroByte = aAddr.u.iAddr8[i];

			while ((nonZeroByte & 1) == 0)

				{

				count += 1;

				nonZeroByte >>= 1;

				}

			break;

			}

		count += 8;

		}

	return 128-count;

	}

LOCAL_C TInt MaskLength(TUint32 aAddr)

	{

	TInt count = 0;

	// obviously, this is "brute force" counting

	while (aAddr & 0x80000000)

		{

		count++;

		aAddr <<= 1;

		}

	return count;

	}

// TRawAddr

// *********

// Lightweight internal help class for handling the link layer addresses

//

class TRawAddr : public TSockAddr

	{

public:

	void Output(TDes& aBuf) const

		{

		TUint8* p = (TUint8*)UserPtr();

		TInt len = ((TSockAddr *)this)->GetUserLen();	//lint !e1773 // it's a kludge but works anyway

		aBuf.SetLength(0);

		if (len == 0)

			return;

		if (aBuf.MaxLength() < len * 4)

			{

			aBuf.Fill('*', aBuf.MaxLength());

			return;

			}

		if (len == 0)

			return;

		for (;;)

			{

			aBuf.AppendFormat(_L("%02X"), *p++ & 0xFF);

			if (--len == 0)

				break;

			aBuf.Append(TChar(':'));

			}

		}

	inline static TRawAddr& Cast(const TSockAddr& aAddr)

		{

		return *((TRawAddr *)&aAddr); //lint !e1773 // standard way to implement Cast

		}

	inline static TRawAddr& Cast(const TSockAddr* aAddr)

		{

		return *((TRawAddr *)aAddr); //lint !e1773 // standard way to implement Cast

		}

	};

//

CIpAdmEngine::~CIpAdmEngine()

	{

	//

	// Ordering is important... Do not close iSS before

	// all sockets associated with it have been closed!

	//

	iFS.Close();

	iSS.Close();

	}

void CIpAdmEngine::ConstructL()

	{

	//

	// Start Socket Reader activity

	//

	CheckResultL(_L("Active Scheduler"), CActiveScheduler::Current() == NULL);

	CheckResultL(_L("Connect to File server"), iFS.Connect());

	CheckResultL(_L("Connect to Socket server"), iSS.Connect());

	}

LOCAL_C void AppendIpAddress(TDes &buf, const TDesC &aLabel, const TInetAddr &aAddr, TInt aSkip = 1)

	{

	if (aSkip && aAddr.IsUnspecified())

		return;

	TBuf<64> out;

	buf.Append(aLabel);

#ifdef HURRICANE_INSOCK

	aAddr.Output(out);

#else

	aAddr.OutputWithScope(out);

#endif

	buf.Append(out);

	}

LOCAL_C void AppendRawAddress(TDes &buf, const TDesC &aLabel, const TSockAddr &aAddr)

	{

	if (aAddr.Family() == KAFUnspec)

		return;

	TBuf<100> out;

	buf.Append(aLabel);

	TRawAddr::Cast(aAddr).Output(out);

	buf.Append(out);

	}

LOCAL_C void AppendIpMask(TDes &buf, const TInetAddr &aAddr)

	{

	if (aAddr.Family() == KAfInet6)

		buf.AppendFormat(_L("/%d"), MaskLength(aAddr.Ip6Address()));

	else

		buf.AppendFormat(_L("/%d"), MaskLength(aAddr.Address())); 

	}

void CIpAdmEngine::Show(TInt /*aVersion*/, const TSoInetInterfaceInfo &aInfo)

	{

	TBuf<1000> buf;

	buf = _L("if ");

	AppendInterfaceStatus(buf, aInfo.iState);

	AppendInterfaceName(buf, aInfo.iName);

	AppendIpAddress(buf, _L(" addr="), (const TInetAddr &)aInfo.iAddress, 0);

	AppendIpMask(buf, (const TInetAddr &)aInfo.iNetMask);

	AppendIpAddress(buf, _L(" bcast="), (const TInetAddr &)aInfo.iBrdAddr);

	AppendIpAddress(buf, _L(" gw="), (const TInetAddr &)aInfo.iDefGate);

	AppendIpAddress(buf, _L(" ns1="), (const TInetAddr &)aInfo.iNameSer1);

	AppendIpAddress(buf, _L(" ns2="), (const TInetAddr &)aInfo.iNameSer2);

	AppendRawAddress(buf, _L(" hwa="), aInfo.iHwAddr);

	buf.AppendFormat(_L(" Mtu=%d, SM=%d, F=%x"), aInfo.iMtu, aInfo.iSpeedMetric, (TUint)aInfo.iFeatures);

	ShowText(buf);

	}

void CIpAdmEngine::Show(TInt /*aVersion*/, const TSoInetRouteInfo &aInfo)

	{

	TBuf<1000> buf;

	buf = _L("rt");

	AppendRouteType(buf, aInfo.iType);

	AppendRouteState(buf, aInfo.iState);

	AppendIpAddress(buf, _L(""), (const TInetAddr &)aInfo.iDstAddr, 0);

	AppendIpMask(buf, (const TInetAddr &)aInfo.iNetMask);

	// the iIfAddr is actually the src address to be used for this route destination

	AppendIpAddress(buf, _L(" src="), (const TInetAddr &)aInfo.iIfAddr);

	if (aInfo.iGateway.Family() == KAfInet6 || aInfo.iGateway.Family() == KAfInet)

		AppendIpAddress(buf, _L(" gw="), (const TInetAddr &)aInfo.iGateway);

	else

		AppendRawAddress(buf, _L(" hwa="), aInfo.iGateway);

	buf.AppendFormat(_L(" M=%d"), aInfo.iMetric);

	ShowText(buf);

	}

void CIpAdmEngine::ListInterfaces(TInt aVersion, const TDesC &aProtocol)

	{

	RSocket socket;

	if (CheckResult(aProtocol, socket.Open(iSS, aProtocol)) != KErrNone)

		return;

	if (socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl) == KErrNone)

		{

		TPckgBuf<TSoInetInterfaceInfo> opt;

		while (socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt) == KErrNone)

			Show(aVersion, opt());

		}

	socket.Close();

	}

void CIpAdmEngine::ListRoutes(TInt aVersion, const TDesC &aProtocol)

	{

	RSocket socket;

	if (CheckResult(aProtocol, socket.Open(iSS, aProtocol)) != KErrNone)

		return;

	if (socket.SetOpt(KSoInetEnumRoutes, KSolInetRtCtrl) == KErrNone)

		{

		TPckgBuf<TSoInetRouteInfo> opt;

		while (socket.GetOpt(KSoInetNextRoute, KSolInetRtCtrl, opt) == KErrNone)

			Show(aVersion, opt());

		}

	socket.Close();

	}

class TParser : public TLex

	{

public:

	TParser(const TDesC &aStr);

	void NextToken();

	int SkipSpaceAndMark();

	TInt ParameterValue(const TDesC &aKey, TInt &aValue, const TInt aDefault = 0);

	TInt ParameterValue(const TDesC &aKey, TInetAddr &aValue);

	TLexMark iLine;

	TLexMark iCurrent;

	TPtrC iLastLine;

	TPtrC Line();

	inline void MarkLine() { iCurrent = iLine; iOpen = 1; }

	TPtrC iToken;

	TInt iOpen;

	TInt iFirst;	// Non-zero, if next token is first in line

	};

#pragma warning (disable:4097)

TParser::TParser(const TDesC &aStr) : TLex(aStr), iLine(), iCurrent(), iLastLine(), iToken(), iOpen(0), iFirst(1)

	{

	Mark(iLine);

	MarkLine();

	}

#pragma warning (default:4097)

//

// Return current line as a descriptor

// (and skip to the next line, if not fully parsed)

//

TPtrC TParser::Line()

	{

	if (iOpen)

		{

		// Line not fully parsed yet, search to the EOL

		while (!Eos())

			{

			TChar ch = Get();

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

				{

				iLastLine.Set(MarkedToken(iCurrent));

				iOpen = 0;

				Mark(iLine);

				break;

				}

			}

		}

	return iLastLine;

	}

//

// Skip white space and mark, including comments!

//

int TParser::SkipSpaceAndMark()

	{

	TChar ch;

	TInt comment = 0;

	TInt newline = 0;

	while (!Eos())

		{

		ch = Get();

		if (ch =='\n')

			{

			comment = 0;

			newline = 1;

			if (iOpen)

				{

				iLastLine.Set(MarkedToken(iCurrent));

				iOpen = 0;

				}

			Mark(iLine);

			}

		else if (comment || ch == '#')

			comment = 1;

		else if (!ch.IsSpace())

			{

			UnGet();

			break;

			}

		}

	Mark();

	return newline;

	}

//

// Extract Next token and return

//

void TParser::NextToken()

	{

	if (SkipSpaceAndMark())

		iFirst = 1;		// New line!

	if (Eos())

		{

		iFirst = -1;

		return;

		}

	while (!Eos())

		{

		TChar ch = Peek();

		if (ch == '#' || ch.IsSpace())

			break;

		Inc();

		}

	iToken.Set(MarkedToken());

	iFirst = SkipSpaceAndMark();

	}

TInt TParser::ParameterValue(const TDesC &aKey, TInt &aValue, const TInt aDefault)

	{

	if (aKey.Compare(iToken) != 0)

		return KErrNotFound;		// Doesn't match, do nothing

	//

	// When the keyword matches, return is always KErrNone

	// (caller must deduce errors by aDefault.

	//

	if (iFirst)

		aValue = aDefault;

	else if (Val(aValue) == KErrNone)

		iFirst = SkipSpaceAndMark();

	else

		aValue = aDefault;

	return KErrNone;

	}

TInt TParser::ParameterValue(const TDesC &aKey, TInetAddr &aValue)

	{

	if (aKey.Compare(iToken) != 0)

		return KErrNotFound;		// Doesn't match, do nothing

	//

	// When the keyword matches, return is always KErrNone

	// (caller must deduce errors by aDefault.

	//

	if (!iFirst)

		{

		NextToken();

		if (aValue.Input(iToken) == KErrNone)

			return KErrNone;

		}

	aValue.SetFamily(0);

	return KErrNone;

	}

void CIpAdmEngine::AddRoutes(const TDesC &aProtocol)

	{

	TInt err = KErrNone;

	RSocket socket;

	if (CheckResult(aProtocol, socket.Open(iSS, aProtocol)) != KErrNone)

		return;

	HBufC *buf = NULL;

#ifndef __DATA_CAGING__

	TRAP(err, buf = UnicodeLoad::LoadL(iFS, DEFAULT_ROUTES_FILE));

	if (CheckResult(DEFAULT_ROUTES_FILE, err))

#else // __DATA_CAGING__

// get private path

	TFileName filename;

	RFs theFS;

	theFS.Connect();

	theFS.PrivatePath(filename);

	theFS.Close();

	filename.Append(DEFAULT_ROUTES_FILE);

	TRAP(err, buf = UnicodeLoad::LoadL(iFS, filename));

	if (CheckResult(filename, err))

#endif // __DATA_CAGING__

		{

		socket.Close();

		return;

		}

	//lint -save -e613 Trapped above

	TParser inifile(*buf); //lint -restore

	TInt route_count = 0;

	TInt if_count = 0;

	while (!err)

		{

		// Skip until first token in line

		while (inifile.iFirst == 0)

			inifile.NextToken();

		if (inifile.iFirst < 0)

			break;

		//

		// The route file is a simple list of lines with following format

		//

		inifile.NextToken();

		inifile.MarkLine();

		if ((inifile.iToken.Compare(_L("route-add")) == 0))

			{

			//    route-add destination netmask metric gateway interface

			//

			// all except the "metric" are assumed to be addresses

			//

			TPckgBuf<TSoInetRouteInfo> opt;

			opt().iType = ERtUser;

			opt().iState = ERtReady;

			opt().iIfAddr.SetFamily(KAFUnspec);

			for (int i = 0; !err && inifile.iFirst == 0; ++i)

				{

				switch (i)

					{

					case 0:	// Destination

						inifile.NextToken();

						err = (TInetAddr::Cast(opt().iDstAddr)).Input(inifile.iToken);

						break;

					case 1: // Netmask

						inifile.NextToken();

						err = (TInetAddr::Cast(opt().iNetMask)).Input(inifile.iToken);

						break;

					case 2:	// metric

						err = inifile.Val(opt().iMetric);

						break;

					case 3:	// Gateway

						inifile.NextToken();

						if (inifile.iToken.Compare(_L("-")) == 0)

							opt().iGateway.SetFamily(KAFUnspec);

						else

							err = (TInetAddr::Cast(opt().iGateway)).Input(inifile.iToken);

						break;

					case 4: // Interface

						inifile.NextToken();

						if (inifile.iToken.Compare(_L("-")) == 0)

							opt().iIfAddr.SetFamily(KAFUnspec);

						else

							err = (TInetAddr::Cast(opt().iIfAddr)).Input(inifile.iToken);

						break;

					default:

						inifile.NextToken();

						break;

					}

				inifile.SkipSpaceAndMark();

				}

			if (err)

				{

				ShowText(_L("Syntax error on line"));

				ShowText(inifile.Line());

				break;

				}

			else if (CheckResult(inifile.Line(), socket.SetOpt(KSoInetAddRoute, KSolInetRtCtrl, opt)) == KErrNone)

				route_count++;

			}

		else if ((inifile.iToken.Compare(_L("ifconfig")) == 0))

			{

			//

			// For now only simple format