// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32test\ethernet\etherpump.cpp

// Abbreviations - PSP (Professional Symbian Programming)

// 

//

#define __USE_LDDPDD__

#define __USE_TIMER__

#include <e32base.h>

#include <e32base_private.h>

#include <e32cons.h>

#include <e32svr.h>

#include <d32ethernet.h>

#include "activeio.h"

#define LDD_NAME _L("Enet")

#if (!defined __WINS__)

#define PDD_NAME _L("Ethernet")

#else

//#define PDD_NAME _L("EthernetWins")

#define PDD_NAME _L("Ethernet")

#endif

// changed from const to static

//const TUint8 DestMacAddr[] = {0x00,0x50,0xDA,0xE9,0x69,0xCA};

// MAC address with second bit 1

static TUint8 DestMacAddr[] = {0x02,0xB0,0xD0,0x64,0x98,0x02};

// for random functions

#include <e32math.h>

void StripeMem(TUint8 *aBuf, TInt aStartPos, TInt anEndPos, TUint aStartChar, TUint anEndChar, TInt aOffset)

//

// Mark a buffer with repeating byte pattern

//

    {

    TUint character=aStartChar+(aOffset%((anEndChar+1)-aStartChar));

    for (TInt i=aStartPos;i<anEndPos;i++)

	{

	aBuf[i]=(TText8)character;

	if(++character>anEndChar)

	    character=aStartChar;

	}

    }

void StripeDes(TDes8 &aBuf, TInt aStartPos, TInt anEndPos, TUint aStartChar, TUint anEndChar, TInt aOffset)

    {

    StripeMem((TUint8 *)aBuf.Ptr(), aStartPos, anEndPos, aStartChar, anEndChar, aOffset);

    }

TBool CheckMem(TUint8 *aBuf, TInt aStartPos, TInt anEndPos, TUint aStartChar, TUint anEndChar, TInt aOffset)

//

// Mark a buffer with repeating byte pattern

//

    {

    TUint character=aStartChar+(aOffset%((anEndChar+1)-aStartChar));

    for (TInt i=aStartPos;i<anEndPos;i++)

	{

	if (aBuf[i]!=(TText8)character)

	    return EFalse;

	if(++character>anEndChar)

	    character=aStartChar;

	}

    return ETrue;

    }

TBool CheckDes(TDes8 &aBuf, TInt aStartPos, TInt anEndPos, TUint aStartChar, TUint anEndChar, TInt aOffset)

    {

    return CheckMem((TUint8 *)aBuf.Ptr(), aStartPos, anEndPos, aStartChar, anEndChar, aOffset);

    }

void StripeMem32(TUint *aBuf, TInt aStartPos, TInt aEndPos)

//

// Mark a buffer with repeating byte pattern

//

    {

    aStartPos >>= 2;

    aEndPos >>= 2;

    for (TInt i=aStartPos;i<aEndPos;i++)

	{

	aBuf[i]=i<<2;

	}

    }

void StripeDes32(TDes8 &aBuf, TInt aStartPos, TInt anEndPos)

    {

    StripeMem32((TUint*)aBuf.Ptr(), aStartPos, anEndPos);

    }

// Standard Epoc32 Library Console class

static CConsoleBase* console;

// xxxLC means method can Leave and has pushed something on the Cleanup stack

// Caller is responsible for popping it.

CDemoControl* CDemoControl::NewLC()

    {

    CDemoControl* self = new (ELeave) CDemoControl(EPriorityNormal);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

TInt CDemoControl::Callback(TAny* aControl)

// Callback function for timer expiry

// Just pump another packet at the server

// It's a static so call a class member to access private data

    {

    CIOBuffer* buf = ((CDemoControl*)aControl)->CreateSendPacketL();

    ((CDemoControl*)aControl)->iWriteQueue.AddLast(*buf);

    ((CDemoControl*)aControl)->iWriter->WriteL(buf->Ptr());

    return KErrNone;

    }

void CDemoControl::ConstructL()

// Second Phase construction

    {

    // Add us to the Active Scheduler for the thread

    CActiveScheduler::Add(this);

    // Create the Read and Write Active Objects

    // The 'this' pointer is the MxxxNotify callback interface that CDemoControl is derived from

    // Pass a reference to the Server session so they can make read and write requests

    iWriter = CDemoWriter::NewL(*this,iCard);

    iReader = CDemoReader::NewL(*this,iCard);

    User::LoadPhysicalDevice(PDD_NAME);

    User::LoadLogicalDevice(LDD_NAME);

#if (defined __USE_TIMER__)

    iIfState = EIdle;

    iTimer = CPeriodic::NewL(EPriorityNormal);

#endif

    iWriteQueue.SetOffset(CIOBuffer::LinkOffset());

    HelpText();

    }

void CDemoControl::EmptyWriteQueue()

    {

    TSglQueIter<CIOBuffer> iter(iWriteQueue);

    CIOBuffer* buf;

    while (buf = iter++, buf!=NULL)

	{

	iWriteQueue.Remove(*buf);

	delete buf;

	}

    }

CDemoControl::~CDemoControl()

    {

    // Cancel this classes read request to the Console

    Cancel();

    if(iIfState != EIdle)

	{

	EmptyWriteQueue();

	StopCard();

	}

    User::FreeLogicalDevice(LDD_NAME);

    User::FreePhysicalDevice(PDD_NAME);

#if (defined __USE_TIMER__)

    iTimer->Cancel();

    delete iTimer;

#endif

    delete iWriter;

    delete iReader;

    }

void CDemoControl::RequestCharacter()

// Request a character from the CConsoleBase class and set us to Active

    {

    // Read() will result in our iStatus being set to KRequestPending 0x80000001

    console->Read(iStatus);

    // SetActive sets our iActive to ETrue

    SetActive();

    }

void CDemoControl::RunL()

// Mandatory override of pure virtual called from active scheduler Start()

// Key method called when the Active Scheduler semaphore is

// signalled and the iStatus has been completed for this Active Object

    {

    ProcessKeyPress(TChar(console->KeyCode()));

    RequestCharacter();

    // We now return control to the scheduler loop

    }

void CDemoControl::DoCancel()

// Mandatory override of pure virtual, called from Cancel()

    {

    // Cancels an outstanding request to the console

    console->ReadCancel();

    }

static const TUint KEscChar = 0x1b;

void CDemoControl::ProcessKeyPress(TChar aChar)

// Process commands from the console

// Executes in the context of the class RunL()

    {

    TInt err = KErrNone;

    if(aChar == KEscChar)

	{

	// Modifies loop control flag value so the scheduler loop exits

	CActiveScheduler::Stop();

	}

    else if(aChar == 'h' || aChar == 'H')

	{

	HelpText();

	}

    else

	{

	// Add Command Handler Methods here

	switch(aChar)

	    {

	    case 'p'	:

	    case 'P'	:

		TRAP(err,PumpL());

		break;

	    case 'e'	:

	    case 'E'	:

		TRAP(err,EchoL());

		break;

	    case 'r'	:

	    case 'R'	:

		TRAP(err,ReadL());

		break;

	    case 's'	:

	    case 'S'	:

		TRAP(err,StopL());

		break;

		case 'c'	:

		case 'C'	:

		TRAP(err,SendAndCompareEchoL());

		break;

		case 'd'	:

		case 'D'	:

		TRAP(err,ReadAndSetDestMacL());

		break;

		case 'm'	:

		case 'M'	:

			ReadAndDisplaySettings();

		break;				

	    default		:

		break;

	    }

	if(err != KErrNone)

	    {

	    PrintError(aChar);

	    }

	else

	    {

	    _LIT(KMess,"State = %d\r\n");

	    console->ClearScreen();

	    console->SetPos(0,0);

	    console->Printf(KMess,iIfState);

	    }

	}

    }

void CDemoControl::HelpText() const

    {

	_LIT(KMess,"Press 'Esc' to exit \r\nPress 'H' for Help \r\nPress 'P' for Data Pump \r\nPress 'E' for Echo \r\nPress 'R' for Read \r\nPress 'C' for send and Compare echo \r\nPress 'D' to set dest MAC\r\nPress 'M' to display Settings\r\nPress 'S' to Stop");

	console->ClearScreen();

    console->SetPos(0,5);

    console->Printf(KMess);

    }

void CDemoControl::PrintError(TChar aChar)

    {

    //_LIT(KMess,"Command Error = %c State = %d\r\n1 = Idle\r\n2 = Echo\r\n3 = Read\r\n4 = Pump");

	_LIT(KMess,"Command Error = %c State = %d\r\n0 = Idle\r\n1 = Echo\r\n2 = Read\r\n3 = Pump\r\n4 = send & Compare echo");

	console->ClearScreen();

    console->SetPos(0,5);

    console->Printf(KMess,(char)aChar,iIfState);	

    }

void CDemoControl::EchoL()

    {

    if(iIfState != EIdle)

	{

	User::Leave(KErrInUse);

	}

    StartCardL();

    iReadBuffer.SetMax();

    iReadBuffer.FillZ();

    iReader->ReadL(iReadBuffer);

    iIfState = EEcho;

    }

void CDemoControl::PumpL()

    {

    console->ClearScreen();

    if(iIfState != EIdle)

	{

	User::Leave(KErrInUse);

	}

#if (defined __USE_TIMER__)

    iTimer->Start(0,1,TCallBack(Callback,this));

#endif

    StartCardL();

    iReadBuffer.SetMax();

    iReadBuffer.FillZ();

    iReader->ReadL(iReadBuffer);

#if (!defined __USE_TIMER__)

    CIOBuffer* buf = CreateSendPacketL();

    iWriteQueue.AddLast(*buf);

    iWriter->WriteL(buf->Ptr());

#endif

    iIfState = EPump;

    }

void CDemoControl::ReadAndDisplaySettings()

//

// Read and display the current config

//

    {

    TBuf8<32> config;

    User::LeaveIfError(iCard.Open(0));

    User::After(2000);

    // MAC Address starts at the 4th byte

    config.SetMax();

    iCard.Config(config);

    console->Printf(_L("\n\nEthernet Speed :"));

    switch (config[0])

	{

	case KEthSpeedUnknown:

	    console->Printf(_L(" Unknown\n"));

	    break;

	case KEthSpeedAuto:

	    console->Printf(_L(" Auto\n"));

	    break;

	case KEthSpeed10BaseT:

	    console->Printf(_L(" 10 MBit\n"));

	    break;

	case KEthSpeed100BaseTX:

	    console->Printf(_L(" 100 MBit\n"));

	    break;

	default:

	    console->Printf(_L(" ERROR\n"));

	}

    console->Printf(_L("Duplex Setting :"));

    switch (config[1])

	{

	case KEthDuplexUnknown:

	    console->Printf(_L(" Unknown\n"));

	    break;

	case KEthDuplexAuto:

	    console->Printf(_L(" Auto\n"));

	    break;

	case KEthDuplexFull:

	    console->Printf(_L(" Full\n"));

	    break;

	case KEthDuplexHalf:

	    console->Printf(_L(" Half\n"));

	    break;

	default:

	    console->Printf(_L(" ERROR\n"));

	}

    console->Printf(_L("MAC :"));

    console->Printf(_L(" %2x:%2x:%2x:%2x:%2x:%2x\n\n"),

		 config[2], config[3],

		 config[4], config[5],

		 config[6], config[7]);

	console->Printf(_L("\nPress any key to continue..\n") );

	console->Getch();

	iCard.Close();

    }

CIOBuffer* CDemoControl::CreateSendPacketL()

    {

    CIOBuffer* buf = CIOBuffer::NewL(1500);

    // Copy in the Destination mac address

    buf->Ptr().SetLength(6);

    buf->Ptr().Copy(DestMacAddr,6);

    // Copy in the source mac address read from the driver

    //buf->Ptr().Append(&iConfig[3],6);

	buf->Ptr().Append(&iConfig[2],6);

    // EtherII framing

    buf->Ptr().Append(0x08);

    buf->Ptr().Append(0x06);

    buf->Ptr().SetMax();

    StripeDes(buf->Ptr(), 14, buf->Ptr().Length(), '@', 'Z',0);

    return buf;

    }

void CDemoControl::ReadL()

    {

    if(iIfState != EIdle)

	{

	User::Leave(KErrInUse);

	}

    StartCardL();

    iReadBuffer.SetMax();

    iReadBuffer.FillZ();

    iReader->ReadL(iReadBuffer);

    iIfState = ERead;

    }

CIOBuffer* CDemoControl::CreateRandomPacketL(TInt aOffset)

	{

	CIOBuffer* buf = CIOBuffer::NewL(1500);

	// Copy in the Destination mac address

	buf->Ptr().SetLength(6);

	buf->Ptr().Copy(DestMacAddr,6);

#if (defined __USE_LDDPDD__)

	// Copy in the source mac address read from the driver

	//buf->Ptr().Append(&iConfig[3],6);

	buf->Ptr().Append(&iConfig[2],6);

#else

	buf->Ptr().Append(DummyMac,6);

#endif

	// EtherII framing

	buf->Ptr().Append(0x08);

	buf->Ptr().Append(0x06);

	buf->Ptr().SetMax();

	StripeDes(buf->Ptr(), 14, buf->Ptr().Length(), '@', 'Z',aOffset);

	return buf;

}

TInt CDemoControl::iSendAndEchoCmpCounter = 0;

void CDemoControl::CompareEcho()

{

	iSendAndEchoSame = 

		CheckDes(iReadBuffer, 14, /*iReadBuffer.Length() - 4*/ 1500 - 4, '@', 'Z', iIntRandomOffset);

										// - 4 for trailer

	console->Printf(_L("\r\nSent & Received Random Packet no: %d \r\n"), iSendAndEchoCmpCounter );

	if( iSendAndEchoSame )

		console->Printf( _L("Echo Same: TRUE \r\n") );

	else

		console->Printf( _L("Echo Same: FALSE \r\n") );

}

void CDemoControl::SendAndCompareEchoL()

{

	if(iIfState != EIdle)

		{

		User::Leave(KErrInUse);

		}

	iSendAndEchoSame = EFalse;

	StartCardL();

	// empty write buffer before start - nothing else should write 

	// when iIfState = ESendAndCmpEcho

	EmptyWriteQueue();

	iIfState = ESendAndCmpEcho;

	// time for generating seed for rand function

	TTime time;

	time.HomeTime(); 

	// change seed after 10 frames sent

	if( 0 == (iSendAndEchoCmpCounter % 10) )

	{

		iIntSeed = time.Int64();

	}

	iIntRandomOffset = Math::Rand( iIntSeed );

	CIOBuffer* buf = CreateRandomPacketL( iIntRandomOffset );

	iWriteQueue.AddLast(*buf);

	iWriter->WriteL(buf->Ptr());