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

// Accenture - minor mods to work as an fshell command and fixes to broken logic

//

// Description:

// pingmodel.cpp - icmp echo client engine

// This software has been implemented in the 6PACK

// project at the Mobile Networks Laboratory (MNW)

// http://www.research.nokia.com/projects/6pack/

// REMARKS:

// The application is prepared to admit the option Hop Limit and

// Numeric output (no name resolution), but these options are not used

// because the socket is open in ICMP mode.  To use them need an IP

// socket and IP packets to set the options. Some code is commented and

// can be used in case of need

//

#ifdef IAPSETTING

#include <commdb.h>

#endif

#include <e32math.h>

#include <e32std.h>

//#include <eikenv.h>

//#include <netdial.h>

// IPv6 changes CPing::iType, ComposeFirstIcmpPacket()- ICMPType, Socket Open()

#include "pingmodel.h"

//#include <pingapp.rsg> //resource is not needed as console app

#include "ping_misc.h"

CPing::CPing():CActive(EPriorityStandard),iPacket(0,0),iReceivedData(0,0)

{

	CActiveScheduler::Add(this);	//Adds itself to the scheduler only the first time

}

//Sets all default values. Actually it's no more a L function

void CPing::ConstructL(TPreferences aPref)

{

	// Base class second-phase construction.

	//iHostname=_L("bart.research.nokia.com");	//default initial addr

	//iHostname=_L("127.0.0.1");	//default initial addr

	//iHostname=_L("dead::beef");	//default initial addr

	iHostname=aPref.iHostname;

	iPackLimit = aPref.iFlags & KPingPackLimit;		//Unlimited packets

	iTotalPackets=aPref.iTotalPackets;	//Default packet number when limited number

	iSecWait=aPref.iSecWait;		//Default 1 second

	iPacketDataSize=aPref.iPacketDataSize;	//Default Size

	iQuiet=aPref.iFlags & KPingQuiet;	//No packet info, just statistics

	iVerbose=aPref.iFlags & KPingVerbose;	//Verbose Output. All ICMP packets, not only Echo reply. Default no

	iPattern.Copy(aPref.iPattern);			//Pattern 0xFF (1-filled byte)

	iDebug=aPref.iFlags & KPingDebug;		//Set SO_DEBUG flag

	iLastSecWait=aPref.iLastSecWait;	//Default time to wait for the last packet

#ifdef IAPSETTING

	iIAP = aPref.iIAP;		

#endif

	//Not used by now

	iNumericOutput=EFalse;	//Resolve adresses by default

	iHopLimit=0;			//Time-to-live in hops default 255 ( 1 to 255) (0 means not set)

	iDupPackets=0;			//Duplicated packets

	iRunning=EFalse;		// Tells if there's an Instance of Ping Running

/*

	iReceivedDataBuffer= HBufC8::NewL(iPacketDataSize + ICMP_ECHO_HEADER_SIZE);	//Maximum size of a return packet

	TPtr8 auxPtr(iReceivedDataBuffer->Des());	//must be used here because the buffer changes

	iReceivedData.Set(auxPtr);			//we use an aux var because can't use Des() directly Why??

*/

}

//return the current preferences

void CPing::GetPreferences(TPreferences &aPref)

{	

	aPref.iFlags=0;

	if (iQuiet)

		aPref.iFlags|=KPingQuiet;

	if (iVerbose)

		aPref.iFlags|=KPingVerbose;

	if (iPackLimit)

		aPref.iFlags|=KPingPackLimit;

	if (iDebug)

		aPref.iFlags|=KPingDebug;

	aPref.iSecWait=iSecWait;               //Time between sent packets (Default 1 second)

	aPref.iPacketDataSize=iPacketDataSize;//Default Data Size (not including ICMP header)

	aPref.iTotalPackets=iTotalPackets;  //Number of ICMP Echo Request packets to send

	aPref.iLastSecWait=iLastSecWait;   //Time to wait for the Last packet. Default 2

	aPref.iHostname=iHostname;		//Address to Ping

	aPref.iPattern.Copy(iPattern);

#ifdef IAPSETTING	

	aPref.iIAP = iIAP;

#endif

}

void CPing::DefaultPreferences(TPreferences &aPref)

{	

	aPref.iFlags=KPingVerbose|KPingPackLimit;

	aPref.iSecWait=1;               //Time between sent packets (Default 1 second)

	aPref.iPacketDataSize=56;//Default Data Size (not including ICMP header)

	aPref.iTotalPackets=5;  //Number of ICMP Echo Request packets to send

	aPref.iLastSecWait=2;   //Time to wait for the Last packet. Default 2

	aPref.iPattern=_L("FF");

	aPref.iHostname=_L("127.0.0.1");

#ifdef IAPSETTING

	aPref.iIAP=1;

#endif

}

void CPing::Statistics()

{

	//TBuf<300> aux(_L("==========================================\n"));

	TBuf<300> aux(_L("\n"));

	TReal rLoss=iSentPackets-iRecvPackets-iChksumErrors;	// An error is a received but wrong packet

										//is not masked as received because of time calculations

	if (rLoss<0) 

		rLoss=0;

	TReal rSent=iSentPackets;

	TReal r;

	if (rSent>0)

		r=rLoss/rSent;

	else

		r=0;

	aux.AppendFormat(_L("Lost: %.1f%% Bad: %d"), r*100, iChksumErrors);

	//If there's a timestamp and data received

	if ((iRecvPackets>0) && (iPacketDataSize >= TIMESTAMP_SIZE))

	{

		r=(iTimeSum/iRecvPackets);	//average in ms

		aux.AppendFormat(_L(" Max: %d Min: %d Avg: "),iMaxTime,iMinTime);

		TRealFormat format;	//no decimals

		format.iType|=KDoNotUseTriads;	// no thousands separatorlast

		aux.AppendNum(r,format);

		aux.Append(_L(" ms"));

	}

	if (iDupPackets>0)

		aux.AppendFormat(_L(" Dup: %d"),iDupPackets);

	//aux.Append(_L("\n==========================================\n"));

	iConsole->WriteLine(aux);

}

// Use when data is not going to be displayed in Quiet mode

void CPing::WriteLineIfNotQuiet(const TDesC& abuf)

{

	if (!iQuiet)

		iConsole->WriteLine(abuf);

}

TDes* CPing::GetHostName()

{

	return &iHostname;

}

void CPing::SetHostName(const TDesC& ahostname)

{

	iHostname=ahostname;

}

void CPing::SetConsole(CPingContainer* aConsole)

{

	iConsole=aConsole;

}

CPing::~CPing()

	{

	Cancel();

	delete iPacketData;		// If something leaves.

	delete iReceivedDataBuffer;

	CloseAll();

	}

//Shows the error and set the application as not running. 

//Requires a return after calling it!

void CPing::ErrorL(const TDesC& string,TInt error)

{

	TBuf<150> aux;

	TBuf<100> errtxt;

	//CEikonEnv::Static()->GetErrorText( errtxt,error);

	aux.Format(string);	

	aux.Append(_L(": "));

	aux.Append(errtxt);

	aux.AppendFormat(_L(" (%d)\n"), error);

	WriteLineIfNotQuiet(aux);

	//iRunning=EFalse;

	iSockErrors++;

	if (error==KErrAbort)	//Critical Error

	{

/*		RNetDial xnetdial;

		TBool active;

		xnetdial.Open();

		TInt err=xnetdial.NetworkActive(active);

		if (!active)

		{

			xnetdial.Start();

			err=xnetdial.NetworkActive(active);

		}

*/

		EndPingL();

		User::Leave(0);	// NOT SURE IF IT'S THE BEST WAY!!!

	}

	if (iSockErrors>5)	//To avoid a chain of errors that blocks everything. Should never happen though 

	{

		EndPingL();

		User::Leave(0);	// NOT SURE IF IT'S THE BEST WAY!!!

	}

}

// checksum of the ICMP packet (ICMP header + data)

TUint16 CPing::in_chksum(TUint16* data, TUint len)

{

	TUint16 *d=data;

	TUint left=len;

	TUint32 sum=0;

	TUint16 aux=0;

	while (left > 1)

	{

		sum += *d++;

		left -= 2;		//because adding 16 bits numbers (2 bytes)

	}

	if (left==1)	//If odd length

	{

		*(TUint8*) &aux = *(TUint8*) d;

		sum += aux;

	}

	sum = (sum >> 16) + (sum & 0x0ffff);

	sum += (sum >> 16);

	aux = (TUint16) ~sum;

	return aux;

}

// Clears a bit from the iDup table

void CPing::CLR(TUint16 num)

{

	TInt num256 = num % 256;		//num modulus 256

	TInt pos = num256 >> 5;		//Position of vector iDup

	iDup[pos] &= ~((1 << num % 32 ));

}

// Sets a bit from the iDup table

void CPing::SET(TUint16 num)

{

	TInt num256= num % 256;		//num modulus 256

	TInt pos=num256 >> 5;		//Position of vector iDup

	iDup[pos] |= (1 << num % 32 );

}

// Tests if the bit is set or not

TBool CPing::TEST(TUint16 num)

{

	TUint num256= num % 256;		//num modulus 256

	TInt pos=num256 >> 5;		//Position of vector iDup

	return ((iDup[pos] & (1 << num % 32)) == (TUint32)(1 << num % 32));

}

//Generates a random number using iSeed

TUint16 CPing::RandomNumber()

{

	if (iSeed==0)	//Initialize seed randomly with time

	{

		TTime time;

        time.HomeTime();

		iSeed=time.Int64();

    }

    return ((TUint16)Math::Rand(iSeed));	//Just take the lowest 16 bits)

}

// Composes the whole ICMP packet except time stamp and checksum

void CPing::ComposeFirstICMPPacket()

{

	ThdrICMP *hdr;

	TUint firstPos = 0;

	hdr = (ThdrICMP *)&iPacket[0];	// Can use this one for IPv6 because is the same format

	if (iType == IPv4)

		hdr->NetSetType(KICMPTypeEchoRequest);

	else

		hdr->NetSetType(KInet6ICMP_EchoRequest);

	hdr->NetSetCode(KICMPCode);

	iId = RandomNumber();

	((ThdrICMP_Echo *)hdr)->NetSetId(iId);	

	((ThdrICMP_Echo *)hdr)->NetSetSeq(0);

	CLR(0);	// Clears the bit in the received/dup buffer

	// Jump over possible timestamp

	if (iPacketDataSize >= TIMESTAMP_SIZE)

	{

		firstPos = TIMESTAMP_SIZE;

	}

	// The rest is filled with a pattern

	// The last part of the packet may only be a part of the pattern

	TInt i;

	TInt j;

	//First transform the pattern from text to Hexadecimal

	TLex lex;

	//TUint8 hex_num;

	TBuf<2> hex_digit;

	TBuf<2 * MAX_PATTERN_LENGTH> text_pattern;

	TUint8 hex_pattern[MAX_PATTERN_LENGTH];

	if (iPattern.Length() % 2 == 0)

		text_pattern.Copy(iPattern);

	else	//odd size so the pattern is doubled and we have a even size

	{

		text_pattern.Copy(iPattern);

		text_pattern.Append(iPattern);

	}

	for (i = 0; i < text_pattern.Length(); i += 2)

	{

		hex_digit.Copy(text_pattern.Ptr() + i, 2);	//Copy 2 text digits 1 byte

		lex.Assign(hex_digit);

		lex.Val(hex_pattern[i/2], EHex);		//Can't fail because only 2 digits

		//hex_pattern.Append((TUint8 *)&hex_num, sizeof(TUint8));	//Append the hex digit (byte)

	}

	for (j = 0, i = firstPos; (TUint)i < iPacketDataSize; i++, j++)

	{

		iPacket[ICMP_ECHO_HEADER_SIZE + i] = !text_pattern.Length()

			? (TUint8)(i % 256)

			: hex_pattern[j % (text_pattern.Length()/2)];	//hex_pattern is half the size of text pattern

	}

//	TBuf8<150> prova;

//	prova.Copy(iPacket);

	StampPacket();

}

// Only composes timestamp and sequence number and calculates checksum

void CPing::ComposeICMPPacket()

{

	ThdrICMP *hdr = (ThdrICMP *)&iPacket[0];

	TUint16 seq = (TUint16)(((ThdrICMP_Echo *)hdr)->NetGetSeq() + 1);

	((ThdrICMP_Echo *)hdr)->NetSetSeq(seq);	// Next seq. Number

	CLR(seq);	// Clears the bit in the received/dup buffer

	StampPacket();

}

void CPing::StampPacket()

{

	ThdrICMP *hdr = (ThdrICMP *)&iPacket[0];

	if (iPacketDataSize >= TIMESTAMP_SIZE)

	{

		TTime time;

		time.UniversalTime();

		*(TInt64*)&iPacket[8] = time.Int64();	// Converts the time to a Int64 value

	}

	hdr->NetSetChecksum(0);

	hdr->NetSetChecksum(in_chksum((TUint16 *)&iPacket[0], iPacketDataSize + ICMP_ECHO_HEADER_SIZE));

}

//Puts the next seq number in the packet (iPacket)

void CPing::NextSeq()

{

	ThdrICMP_Echo *hdr;

	hdr=(ThdrICMP_Echo *)&iPacket[8];

	hdr->SetSeq((TUint16)((hdr->NetGetSeq()) + 1));

}

//TPtrC CPing::PacketTypev6(TInet6HeaderICMP_Echo *aHdr)

void CPing::PacketTypev6(TDes& buf,ThdrICMP *aHdr)

{

	//TBuf<40> buf;

	TInet6HeaderICMP *hdr = (TInet6HeaderICMP *)aHdr;

	//TInet6HeaderICMP_Echo *echoHdr;

	TInt8 code=hdr->Code();

	switch(hdr->Type())

	{

		//Errors 0-127

		case KInet6ICMP_Unreachable: 

			//buf.Format(_L("type= "));

			buf.Append(_L("Dest. Unreachable: "));

			//buf.Format(_L("type=%d "),type);

			switch (code)

			{

			case KInet6ICMP_NoRoute:

				//buf.Append(_L("code= "));

				buf.Append(_L("No Route "));

				break;

			case KInet6ICMP_AdminProhibition:

				//buf.Append(_L("code= "));

				buf.Append(_L("Admin. Prohibition "));

				break;

			case KInet6ICMP_NotNeighbour:

				//buf.Append(_L("code= "));

				buf.Append(_L("Not a Neighbour "));

				break;

			case KInet6ICMP_AddrUnreach:

				//buf.Append(_L("code= "));

				buf.Append(_L("Addr. Unreachable "));

				break;

			case KInet6ICMP_PortUnreach:

				//buf.Append(_L("code= "));

				buf.Append(_L("Port Unreachable "));

				break;

			default: buf.AppendFormat(_L("code=%d "),code);

			}

			break;

		case KInet6ICMP_PacketTooBig:

			//buf.Format(_L("type= "));

			buf.Append(_L("Pack. Too big "));

			break;

		case KInet6ICMP_TimeExceeded:

			//buf.Format(_L("type= "));

			buf.Append(_L("Time exceeded: "));

			switch (code)

			{

			case KInet6ICMP_HopLimitExceeded:

				//buf.Append(_L("code= "));

				buf.Append(_L("Hop Limit "));

				break;

			case KInet6ICMP_FragReassExceeded:

				//buf.Append(_L("code= "));

				buf.Append(_L("Frag. Reassembly "));

				break;

			default: buf.AppendFormat(_L("code=%d "),code);

			}

			break;

		case KInet6ICMP_ParameterProblem:

			//buf.Format(_L("type= "));

			buf.Append(_L("Parameter problem: "));

			switch (code)

			{

			case KInet6ICMP_ErrHdrField:

				//buf.Append(_L("code= "));

				buf.Append(_L("Bad header filed"));

				break;

			case KInet6ICMP_NextHdrUnknown:

				//buf.Append(_L("code= "));

				buf.Append(_L("Unknown Next Header "));

				break;

			case KInet6ICMP_OptionUnkown:

				//buf.Append(_L("code= "));

				buf.Append(_L("Unknown Option"));

				break;

			default: buf.AppendFormat(_L("code=%d "),code);

			}

			break;

		//Information 128-255

		case KInet6ICMP_EchoRequest:

			//echoHdr=(TInet6HeaderICMP_Echo *)hdr;

			buf.Append(_L("Echo Request "));

			//buf.AppendFormat(_L("id= %d "),echoHdr->Identifier());

			//buf.AppendFormat(_L("Seq= %d "),echoHdr->Sequence());

			break;

		case KInet6ICMP_EchoReply:

			//echoHdr=(TInet6HeaderICMP_Echo *)hdr;

			buf.Append(_L("Echo Reply "));

			//buf.AppendFormat(_L("id= %d "),echoHdr->Identifier());

			//buf.AppendFormat(_L("Seq= %d "),echoHdr->Sequence());

			break;

		case KInet6ICMP_Redirect:

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

			break;

		case KICMPTypeRouterAdvert: 

		case KInet6ICMP_RouterAdv:

			buf.Append(_L("Router advertisement "));

			break;

		case KICMPTypeRouterSolicit: