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

// Started by MWT, June 1997

// 

//

#include <e32cons.h>

#include <c32comm.h>

#include <nifman.h>

#ifdef __WINS__

#define CDRV1_PATH _L("ECDRV")

#define COMM_PATH _L("ECOMM")

#endif

LOCAL_C TInt ProgramL();

const TInt  KHistoryBufferSize = 20;

_LIT(KPrompt, "Command>");

const TInt KPromptLength = 8;

const TInt KQuitReturn = -100;

const TInt KHelpReturn = -101;

class CCircList : public CBase

	{

public:

	CCircList(TInt aLength);

	~CCircList();

	TInt Add(const TDesC& aLine);

	const HBufC& operator[](TInt anIndex) const;

	TInt Count() const;

private:

	RArray<HBufC*> iBufPtrArray;

	TInt iMaxLength;

	};

class CPingTestKeyStroke;

class CPingTestUi : public CBase, public MPingNotificationHandler

    {

public:

	static CPingTestUi* NewL();

	void StartL(const TPingOptions& aOptions);

	~CPingTestUi();

	virtual void Pinging(const TNameRecord& aRecord, TInt aBytes) const;

	virtual void Sent() const;

	virtual void Reply(const TInetAddr& aFrom, TInt aBytes, TInt aSeq, TTimeIntervalMicroSeconds32 aTime) const;

	virtual void Icmp4Message(const TInetAddr& aFrom, TInt aType, TInt aCode, const TDesC8& aRestOfIt) const;

	virtual void Icmp6Message(const TInetAddr& aFrom, TInt aType, TInt aCode) const;

	virtual void Finished(const TNameRecord& aRecord, TInt aNrTransmitted, TInt aNrReceived, TInt aNrDuplicates, TInt aMin, TInt aMax, TInt aSum, TInt aError);

	void SetParams(TBool aFloodFormat);

	void SetKeyStrokeActive();

	void KeyStroke();

	void KeyStrokeDoCancel();

	void AddToHistory(const TDesC& aLine);

	void DisplayHistory(TInt aLine, TInt aPromptLen, TDes& aDes) const;

	inline CConsoleBase& Console() { return *iConsole; }

	TInt NrReceivedPackets() const;

private:

	void ConstructL();

	void InitialiseL();

private:

	TBool iFloodFormat;

	CConsoleBase* iConsole;

	CPingTestKeyStroke* iKeyHandler;

	CCircList* iHistory;

	CPingEng* iEngine;

	TInt iNrReceivedPackets;

	};

inline TInt CPingTestUi::NrReceivedPackets() const

	{

	return iNrReceivedPackets;

	}

class CPingTestKeyStroke : public CActive

	{

public:

	CPingTestKeyStroke(CPingTestUi& aUi);

	~CPingTestKeyStroke();

	void ReStart();

	void RunL();

	void DoCancel();

private:

	CPingTestUi& iUi;

	};

class TPingTestParser

	{

public:

	// returns EFalse if the user wants to exit, ETrue otherwise

	TBool ParseCommandLine(CPingTestUi& aUI);

	TInt ParseCLArguments(TDes& aCommandLine,CPingTestUi& aUI);

	const TPingOptions& Options() const;

	const TPtrC& BadArgument() const;

private:

	TPingOptions iOptions;

	TPtrC iCLArgument;

	};

const TPtrC& TPingTestParser::BadArgument() const

	{

	return iCLArgument;

	}

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	// Standard stuff

	CTrapCleanup* trap = CTrapCleanup::New();

	if(trap==NULL)

		return KErrNoMemory;

	TRAPD(err, ProgramL());

	delete trap;

	__UHEAP_MARKEND;

	return err;

	}

LOCAL_C TInt ProgramL()

	{

	TInt ret = 0;

	CActiveScheduler* as = new(ELeave) CActiveScheduler;

	CleanupStack::PushL(as);

	CActiveScheduler::Install(as);

	HBufC *argsBuf = HBufC::NewMaxLC(512);

	TPtr args(argsBuf->Des());

	User::CommandLine(args);

	CPingTestUi* ui=CPingTestUi::NewL();

	CleanupStack::PushL(ui);

	TPingTestParser parser;

	if (args.Length()!=0)

		{

		TInt res = parser.ParseCLArguments(args,*ui);

		if (res != KErrNone)

			{

			ui->Console().Printf(_L("Invalid argument %S - result %d\n"), &parser.BadArgument(), res);

			}

		else

			{

			ui->SetParams(parser.Options().iInterval.Int()<200000);

			ui->SetKeyStrokeActive();

			ui->StartL(parser.Options());

			CActiveScheduler::Start();

			}

	    ui->Console().Getch();

		}

	else

		for(;;)

		{

			ret = parser.ParseCommandLine(*ui);

			if(ret == KQuitReturn)

				{

				break;

				}

			if(ret != KHelpReturn)

			{

				ui->SetParams(parser.Options().iInterval.Int()<200000);

				ui->SetKeyStrokeActive();

				ui->StartL(parser.Options());

				CActiveScheduler::Start();

			}

		}

	ret = ui->NrReceivedPackets() == 0;

	CleanupStack::PopAndDestroy(ui);

	CleanupStack::PopAndDestroy(argsBuf);

	CleanupStack::PopAndDestroy(as);

	return ret;

	}

CPingTestUi* CPingTestUi::NewL()

//

// Create new test UI

//

	{

	CPingTestUi* ui = new (ELeave) CPingTestUi;

	CleanupStack::PushL(ui);

	ui->ConstructL();

	CleanupStack::Pop(ui);

	return ui;

	}

void CPingTestUi::InitialiseL()

//

// Ensure stuff is loaded etc

//

	{

#ifndef __EPOC32__

	User::LoadPhysicalDevice(CDRV1_PATH);    

    	User::LoadLogicalDevice(COMM_PATH);

#endif

//	User::LeaveIfError(Nifman::CheckIniConfig());

	}

void CPingTestUi::ConstructL()

//

// Contruct engine and console

//

	{

	iConsole = Console::NewL(_L("Ping"),TSize(KConsFullScreen,KConsFullScreen));

	_LIT(KPhbkSyncCMI, "phbsync.cmi");

    	(void)StartC32WithCMISuppressions(KPhbkSyncCMI);

	iEngine=CPingEng::NewL(*this);

	iKeyHandler = new (ELeave) CPingTestKeyStroke(*this);

	iHistory = new (ELeave) CCircList(KHistoryBufferSize);

	InitialiseL();

	}

CPingTestUi::~CPingTestUi()

//

// Delete console

//

	{

	delete iHistory;

	delete iKeyHandler;

	delete iConsole;

	delete iEngine;

	}

void CPingTestUi::StartL(const TPingOptions& aOptions)

	{

	iEngine->StartL(aOptions);

	}

void CPingTestUi::AddToHistory(const TDesC& aLine)

//

// Add line to history buffer

//

	{

	iHistory->Add(aLine);

	}

void CPingTestUi::DisplayHistory(TInt aLine, TInt aPromptLen, TDes& aDes) const

	{

	aDes.SetLength(0);

	if(!iHistory->Count())

		{

		return;

		}

	const HBufC& line=(*iHistory)[aLine];

	iConsole->SetPos(aPromptLen);

	iConsole->ClearToEndOfLine();

	iConsole->Write(line);

	aDes.Append(line);

	}

void CPingTestUi::Pinging(const TNameRecord& aRecord, TInt aBytes) const

//

//	Who are we pinging ??

//

	{

	TName ipaddr;

	TInetAddr& addr = (TInetAddr&)aRecord.iAddr;

	addr.Output(ipaddr);

	if(aRecord.iName.Length())

		{

		iConsole->Printf(_L("Pinging %S [%S] with %d bytes of data\n"), &aRecord.iName, &ipaddr, aBytes);

		}

	else

		{

		iConsole->Printf(_L("Pinging %S with %d bytes of data\n"), &ipaddr, aBytes);

		}

	}

void CPingTestUi::Reply(const TInetAddr& aFrom, TInt aBytes, TInt aIcmpSeq, TTimeIntervalMicroSeconds32 aTime) const

//

// Reply from remote host

//

	{

	if(iFloodFormat)

		{

		iConsole->Write(_L("."));

		return;

		}

	TName inetaddr;

	aFrom.Output(inetaddr);

	if(aTime.Int()<15000)

		{

		iConsole->Printf(_L("Reply from %S  len=%d seq %d time<15ms\n"), &inetaddr, aBytes, aIcmpSeq);

		}

	else

		{

		iConsole->Printf(_L("Reply from %S  len=%d seq %d time=%dms\n"), &inetaddr, aBytes, aIcmpSeq, aTime.Int()/1000);

		}

	}

void CPingTestUi::Sent() const

//

//

//

	{

	if(iFloodFormat)

		{

		iConsole->Write(_L("\b"));

		}

	}

void CPingTestUi::Icmp4Message(const TInetAddr& aAddr, TInt aType, TInt aCode, const TDesC8& aData) const

//

//

//

	{

	TBuf<39> inetaddr;

	aAddr.Output(inetaddr);

	iConsole->Printf(_L("Reply from %S: len=%d "), &inetaddr, aData.Length()+4);

	switch(aType)

		{

	case KIPv4PingTypeEchoReply:

		iConsole->Printf(_L("Echo Reply\n"));

		break;

	case KIPv4PingTypeUnreachable:

		switch(aCode)

			{

		case KIPv4PingCodeUnreachNet:

			iConsole->Printf(_L("Destination Net Unreachable\n"));

			break;

		case KIPv4PingCodeUnreachHost:

			iConsole->Printf(_L("Destination Host Unreachable\n"));

			break;

		case KIPv4PingCodeUnreachProtocol:

			iConsole->Printf(_L("Destination Protocol Unreachable\n"));

			break;

		case KIPv4PingCodeUnreachPort:

			iConsole->Printf(_L("Destination Port Unreachable\n"));

			break;

		case KIPv4PingCodeUnreachNeedFrag:

			iConsole->Printf(_L("Fragmentation Needed and DF Set\n"));

			break;

		case KIPv4PingCodeUnreachSrcRouteFail:

			iConsole->Printf(_L("Source Route Failed\n"));

			break;

		case KIPv4PingCodeUnreachNetUnknown:

			iConsole->Printf(_L("Destination Network Unknown\n"));

			break;

		case KIPv4PingCodeUnreachHostUnknown:

			iConsole->Printf(_L("Destination Host Unknown\n"));

			break;

		case KIPv4PingCodeUnreachSrcHostIsolated:

			iConsole->Printf(_L("Source Host Isolated\n"));

			break;

		case KIPv4PingCodeUnreachNetProhibited:

			iConsole->Printf(_L("Destination Network Prohibited\n"));

			break;

		case KIPv4PingCodeUnreachHostProhibited:

			iConsole->Printf(_L("Destination Host Prohibited\n"));

			break;

		case KIPv4PingCodeUnreachNetTOS:

			iConsole->Printf(_L("Network Unreachable for TOS\n"));

			break;

		case KIPv4PingCodeUnreachHostTOS:

			iConsole->Printf(_L("Host Unreachable for TOS\n"));

			break;

		case KIPv4PingCodeUnreachProhibited:

			iConsole->Printf(_L("Prohibited by Filtering\n"));

			break;

		case KIPv4PingCodeUnreachPrecVolation:

			iConsole->Printf(_L("Precedence Violation\n"));

			break;

		case KIPv4PingCodeUnreachPrecCutoff:

			iConsole->Printf(_L("Precedence Cutoff in Effect\n"));

			break;

		default:

			iConsole->Printf(_L("Dest Unreachable, Bad Code: %d\n"), aCode);

			break;

			}

		break;

	case KIPv4PingTypeSourceQuench:

		iConsole->Printf(_L("Source Quench\n"));

		break;

	case KIPv4PingTypeRedirect:

		switch(aCode) 

			{

		case KIPv4PingCodeRedirectNet:

			iConsole->Printf(_L("Redirect Network"));

			break;

		case KIPv4PingCodeRedirectHost:

			iConsole->Printf(_L("Redirect Host"));

			break;

		case KIPv4PingCodeRedirectNetTOS:

			iConsole->Printf(_L("Redirect Type of Service and Network"));

			break;

		case KIPv4PingCodeRedirectHostTOS:

			iConsole->Printf(_L("Redirect Type of Service and Host"));

			break;

		default:

			iConsole->Printf(_L("Redirect, Bad Code: %d"), aCode);

			break;

			}

		iConsole->Printf(_L("(New addr: %d.%d.%d.%d)\n"), aData[0], aData[1], aData[2], aData[3]);

		break;

	case KIPv4PingTypeTimeExceeded:

		switch(aCode)

			{

		case KIPv4PingCodeExceedInTransit:

			iConsole->Printf(_L("Time to live exceeded\n"));

			break;

		case KIPv4PingCodeExceedInReasm:

			iConsole->Printf(_L("Frag reassembly time exceeded\n"));

			break;

		default:

			iConsole->Printf(_L("Time exceeded, Bad Code: %d\n"), aCode);

			break;

			}

		break;

	case KIPv4PingTypeBadParameter:

		iConsole->Printf(_L("Parameter problem: pointer = 0x%02x\n"), *(TUint*)aData.Ptr());

		break;

	default:

		iConsole->Printf(_L("Bad ICMPv4 type: %d\n"), aType);

		}

	}

void CPingTestUi::Icmp6Message(const TInetAddr& aAddr, TInt aType, TInt aCode) const

	{

	TBuf<39> inetaddr;

	aAddr.Output(inetaddr);

	iConsole->Printf(_L("Reply from %S: "), &inetaddr);

	switch(aType)

		{

		case KIPv6PingTypeEchoReply:

			iConsole->Printf(_L("Echo Reply\n"));

			break;

		case KIPv6PingTypeUnreachable:

			switch (aType)

				{

			case KIPv6PingCodeNoRoute:

				iConsole->Printf(_L("No route to destination\n"));

				break;

			case KIPv6PingCodeAdminProhibited:

				iConsole->Printf(_L("Communication administratively prohibited\n"));

				break;

			case KIPv6PingCodeAddressUnreachable:

				iConsole->Printf(_L("Address unreachable\n"));

				break;

			case KIPv6PingCodePortUnreachable:

				iConsole->Printf(_L("Port unreachable\n"));

				break;

			default:

				iConsole->Printf(_L("Unreachable, bad code: %d\n"), aCode);

				break;

				}

			break;

		case KIPv6PingTypePacketTooBig:

			iConsole->Printf(_L("Packet too big"));

			break;

		case KIPv6PingTypeTimeExeeded:

			switch (aType)

				{

			case KIPv6PingCodeHLExeeded:

				iConsole->Printf(_L("Hop limit exceeded in transit\n"));

				break;

			case KIPv6PingCodeFragReassemblyExeeded:

				iConsole->Printf(_L("Fragment reassembly time exceeded\n"));

				break;

			default:

				iConsole->Printf(_L("Time exceeded, bad code: %d\n"), aCode);

				}

			break;

		case KIPv6PingTypeParamProblem:

			switch(aCode)

				{

			case KIPv6PingCodeErroneousHeader: