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

//

#include <e32hal.h>

#include <icmp6_hdr.h>

#include <in_chk.h>

#include <commdbconnpref.h>

#include <connpref.h>

const TInt KDefaultPings =  4;

const TInt KDefaultInterval = 1000000;

const TInt KDefaultWait = 10000000;

const TInt KDefaultPingSize = 32;

const TInt KDefaultBacklog = 512;

const TInt KMaxTimeOnQue=KDefaultBacklog*KDefaultInterval;

const TInt KMaxSendTime=60000000;

const TUint KIcmpHeaderSize = 8;

const TUint KMinIpHeaderSize = 20;

class CPingTimer : public CTimer

	{

friend class CPingEng;

protected:

	CPingTimer(CPingEng& aParent);

	void RunL();

private:

	CPingEng& iParent;

	};

class CPingSender : public CActive

	{

friend class CPingEng;

protected:

	CPingSender(CPingEng& aParent);

	~CPingSender();

	void RunL();

	void DoCancel();

private:

	CPingEng& iParent;

	};

class CPingReceiver : public CActive

	{

friend class CPingEng;

protected:

	CPingReceiver(CPingEng& aParent);

	~CPingReceiver();

	void RunL();

	void DoCancel();

private:

	CPingEng& iParent;

	};

class HPingHeader : public TInet6HeaderICMP_Echo

	{

public:

	static HPingHeader* NewL(TInt aSize = KIcmpHeaderSize, TUint aIPVersion = KAfInet);

	~HPingHeader();

	TBool VerifyRecvEcho(TInt aId);

	TBool VerifyNonEcho(TInt aId);

	void SetVersion(TUint aIPVersion);

	void FormatSend(TUint aId, TUint aSeqNum);

	TInt MaxLength();

	TInt DataLength();

	TPtr8* Grab();

	TPtrC8 IcmpContents();

private:

	void ConstructL(TInt aSize, TUint aIPVersion);

	TBool SetHeader(TUint aOffset = 0);

	HBufC8* iData;

	TPtr8* iDataPtr;

	TUint iIPVersion;

	TInt iSize;

	};

enum TPingEngPanic

	{

	ETimerPriorityGreaterThanSender,	// 0

	ESenderPrirityGreaterThanReceiver	// 1

	};

LOCAL_C void Panic(TPingEngPanic aPanic)

//

// Panic the user

//

	{

	User::Panic(_L("PingEng"), aPanic);

	}

EXPORT_C TPingOptions::TPingOptions()

//

// Default ping options

//

	{

	iNumberOfPings=KDefaultPings;

	iInterval = KDefaultInterval;

	iWait = KDefaultWait;

	iPingSize=KDefaultPingSize;

	iResolveAddress=EFalse;

	iPrompt=EFalse;

	iConnIap=0;

	iConnSnap=0;

	iPreload=0;

	iBacklog=KDefaultBacklog;

	}

EXPORT_C CPingEng* CPingEng::NewL(MPingNotificationHandler& aUi)

//

// Create a new ping engine

//

	{

	CPingEng* p= new(ELeave) CPingEng(aUi);

	CleanupStack::PushL(p);

	p->ConstructL();

	CleanupStack::Pop(p);

	return p;

	}

CPingEng::CPingEng(MPingNotificationHandler& aUi)

: iUi(aUi)

//

// Declare a name

//

	{	

	__DECLARE_NAME(_S("CPingEng"));

	}

EXPORT_C CPingEng::~CPingEng()

//

// Destroy wot ping created

	{

	iSocket.Close();

	iResolver.Close();

	iConnect.Close();

	iSocketServ.Close();

	delete iReceiver;

	delete iSender;

	delete iTimer;

	delete iRecvData;

	delete iSendData;

	EmptyPingRecordQue();

	}

void CPingEng::EmptyPingRecordQue()

	{

	while (!iQue.IsEmpty())

		{

		DeletePingRecord(iQue.First());

		}

	}

void CPingEng::DeletePingRecord(TPingRecord* aRecord)

	{

	iQue.Remove(*aRecord);

	delete aRecord;

	iNoInQue--;	

	}

void CPingEng::ConstructL()

//

// Construct and heap objects

//

	{

	iQue.SetOffset(_FOFF(TPingRecord, iLink));

	iTimer = new (ELeave) CPingTimer(*this);

	iTimer->ConstructL();

	iSender = new (ELeave) CPingSender(*this);

	iReceiver = new (ELeave) CPingReceiver(*this);

	User::LeaveIfError(iSocketServ.Connect());

	}

EXPORT_C void CPingEng::SetPriorities(TInt aTimerPriority, TInt aSenderPriority, TInt aReceiverPriority)

//

//	Set various active object priorities

//

	{	

	__ASSERT_ALWAYS(aTimerPriority < aSenderPriority, Panic(ETimerPriorityGreaterThanSender));

	__ASSERT_ALWAYS(aSenderPriority < aReceiverPriority, Panic(ESenderPrirityGreaterThanReceiver));

	iTimer->SetPriority(aTimerPriority);

	iSender->SetPriority(aSenderPriority);

	iReceiver->SetPriority(aReceiverPriority);

	}

EXPORT_C void CPingEng::StartL(const TPingOptions& aOptions)

//

// Start a ping

//

	{

	// Reset All Variables

	iNrTransmitted=0;

	iNrReceived=0;

	iNrDuplicates=0;

	iMinTime=KMaxTInt;

	iMaxTime=0;

	iSumTime=0;

	iId=User::TickCount()&KMaxTUint16;

	iNameEntry().iName.SetLength(0);

	iNameEntry().iFlags=0;

	iIsLoopback = EFalse;

	iOptions=aOptions;

	if(iOptions.iDestname.Length()>0)

		{	

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

		const TBool addressInputValid = addr.Input(iOptions.iDestname) == KErrNone;

		if (addressInputValid)

		    {

            iIsLoopback = addr.IsLoopback();

		    }

		iConnect.Close();

		// Make a connection only if it is required.

		//

		if (!iIsLoopback)

            {

            // This branch will unfortunately be taken if the call to TInetAddr.Input() fails.

    		User::LeaveIfError(iConnect.Open(iSocketServ, KConnectionTypeDefault));

			if(iOptions.iConnSnap)

				{

				TConnSnapPref connPref(iOptions.iConnSnap);

				User::LeaveIfError(iConnect.Start(connPref));

				}

			else

				{

				TCommDbConnPref commDbPref;

				if(iOptions.iConnIap)

					{

					commDbPref.SetIapId(iOptions.iConnIap);

					}

				if(!iOptions.iPrompt)

					{

					commDbPref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

					}

				else

					{

					commDbPref.SetDialogPreference(ECommDbDialogPrefPrompt);

					}

				User::LeaveIfError(iConnect.Start(commDbPref));

				}			

			}

        TInt err;

		if (addressInputValid)

			{

			if(iOptions.iResolveAddress)

				{

				if((err=iResolver.Open(iSocketServ, KAfInet, KProtocolInetUdp, iConnect))==KErrNone)

					{

					iState=ELookingUp;

					iResolver.GetByAddress(addr, iNameEntry, iSender->iStatus);

					iSender->SetActive();

					iTimer->After(KMaxSendTime);

					}

				else

					{

					DoError(err);

					}

				}

			else

				{

				iSender->iStatus=KErrNone;

				iState=ELookingUp;

				SendCompleteL();

				}

			}

		else

			{

			if((err=iResolver.Open(iSocketServ, KAfInet, KProtocolInetUdp, iConnect))==KErrNone)

				{

				iState=ELookingUp;

				iResolver.GetByName(iOptions.iDestname, iNameEntry, iSender->iStatus);

				iSender->SetActive();

				iTimer->After(KMaxSendTime);

				}

			else

				{

				DoError(err);

				}

			}

		}

	else

		{

		DoError(KErrBadName);

		}

	}

EXPORT_C void CPingEng::CancelAndFinished()

//

// Cancel from the UI

//

	{

	if(iState!=EStopped || iTimer->IsActive())

		{

		Cancel();

		iUi.Finished(iNameEntry(), iNrTransmitted, iNrReceived, iNrDuplicates, iMinTime, iMaxTime, iSumTime, KErrCancel);

		}

	}

EXPORT_C void CPingEng::Cancel()

//

// Cancel a ping in progress

//

	{

	iSender->Cancel();

	iReceiver->Cancel();	

	iTimer->Cancel();

	iSocket.Close();

	iConnect.Close();

	iResolver.Close();

	EmptyPingRecordQue();

	iState=EStopped;

	}

void CPingEng::DoError(TInt aError)

//

// Generate an error from somewhere

//

	{

	Cancel();

	iTimer->SetActive();

	TRequestStatus* p = &iTimer->iStatus;

	User::RequestComplete(p, aError);

	}

void CPingEng::TimerComplete()

//

// Timer event completed

//

	{

	if(iTimer->iStatus==KErrNone)

		{

		if((iOptions.iNumberOfPings && iNrTransmitted>=iOptions.iNumberOfPings)

			|| iSender->IsActive())

			{

			Cancel();

			iUi.Finished(iNameEntry(), iNrTransmitted, iNrReceived, iNrDuplicates, iMinTime, iMaxTime, iSumTime, KErrTimedOut);

			}

		else

			{

			PurgeQue();

			NextSend();

			}

		}

	else

		{

		iUi.Finished(iNameEntry(), iNrTransmitted, iNrReceived, iNrDuplicates, iMinTime, iMaxTime, iSumTime, iTimer->iStatus.Int());

		}

	}

void CPingEng::SendCompleteL()

//

// A send operation has completed

//

	{

	if(iState==ELookingUp)

		{

		iResolver.Close();

		}

	if(iSender->iStatus!=KErrNone)

		{

 		DoError(iSender->iStatus.Int());

		return;

		}

	iTimer->Cancel();

	if(iState==ELookingUp) // Intiate the ping process

		{

		delete iSendData;

		iSendData = NULL;

		delete iRecvData;

		iRecvData = NULL;

		TInt res=KErrNone;

		// Set up socket and recieve/send packets depending on address type.

		switch(iNameEntry().iAddr.Family())

			{

		case KAfInet:

			{

			iSendData = HPingHeader::NewL(iOptions.iPingSize);

			iRecvData = HPingHeader::NewL(iOptions.iPingSize);

			if(!iRecvData || !iSendData)

				{

				DoError(KErrNoMemory);

				return;

				}

			if (iIsLoopback)

			    {

    			res=iSocket.Open(iSocketServ, KAfInet, KSockDatagram, KProtocolInetIcmp);

			    }

			else

		        {

      			res=iSocket.Open(iSocketServ, KAfInet, KSockDatagram, KProtocolInetIcmp, iConnect);

		        }

			break;

			}

		case KAfInet6:

			{

			iSendData = HPingHeader::NewL(iOptions.iPingSize, KAfInet6);

			iRecvData = HPingHeader::NewL(iOptions.iPingSize, KAfInet6);

			if(!iRecvData || !iSendData)

				{

				DoError(KErrNoMemory);

				return;

				}

			if (iIsLoopback)

			    {

    			res=iSocket.Open(iSocketServ, KAfInet, KSockDatagram, KProtocolInet6Icmp);

			    }

			else

			    {

    			res=iSocket.Open(iSocketServ, KAfInet, KSockDatagram, KProtocolInet6Icmp, iConnect);

			    }

			break;

			}

		default:

			DoError(KErrGeneral);

			return;

			}

		if(res==KErrNone)

			{

			res=iSocket.SetOpt(KSORecvBuf, KSOLSocket, iRecvData->MaxLength());

			}

		if(res==KErrNone)

			{

			res=iSocket.SetOpt(KSOSendBuf, KSOLSocket, iSendData->MaxLength());

			}

		if(res!=KErrNone)

			{

			DoError(res);

			return;

			}

		// Start the receiver

		iSocket.RecvFrom(*(iRecvData->Grab()), iSrcAddr, 0, iReceiver->iStatus);

		iReceiver->SetActive();

		// Tell the UI

		iUi.Pinging(iNameEntry(),iOptions.iPingSize);

		iState=ESending;

	    	NextSend();

		}

	else // Start appropriate timer

		{

		iUi.Sent();

		if(!iOptions.iNumberOfPings || iNrTransmitted<iOptions.iNumberOfPings)

			{

			if(iOptions.iPreload || !iOptions.iInterval.Int())

				{

				if(iOptions.iPreload>0)

					{

					--iOptions.iPreload;

					}

				iTimer->iStatus=KErrNone;

				TimerComplete();

				}

			else

				{

				iTimer->After(iOptions.iInterval);

				}

			}

		else if(iNrReceived)

			{

			iTimer->After(iMaxTime>500000 ? (iMaxTime*5) : 1000000);

			}

		else

			{

			iTimer->After(iOptions.iWait);

			}

		}