// 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());

}

void CDemoControl::HandleWriteCompleteSndCmpEchoModeL()

{

	CIOBuffer* buf = iWriteQueue.First();

	iWriteQueue.Remove(*buf);

	delete buf;

	iSendAndEchoCmpCounter = ++iSendAndEchoCmpCounter;

	// empty read buffer

	iReadBuffer.SetMax();

	iReadBuffer.FillZ();	

	// read echo

	iReader->ReadL(iReadBuffer);

}

void CDemoControl::HandleReadCompleteSndCmpEchoModeL()

{

	CompareEcho();

	// empty read buffer

	iReadBuffer.SetMax();

    iReadBuffer.FillZ();

//	iIfState = EIdle;

}

void CDemoControl::ReadAndSetDestMacL()

{

	TUint8 upper=0;

	TInt i =0;

	//TInt consPos = 0;

	TChar c;

	TInt pos; 

	TUint8 value;

	TBuf<20> validChars(_L("0123456789abcdef"));

	TUint8 newDestMacAddr[] = {0x00,0x00,0x00,0x00,0x00,0x00};

	_LIT(KMess,"Type new dest MAC (12 hexagonal digits):\r\n");

	console->ClearScreen();

	console->SetPos(0,0);

	console->Printf(KMess,iIfState);

	for(i = 0; i < 12; i++)

	{

		c = console->Getch();

		c.LowerCase();

		if((pos = validChars.Locate(c))==KErrNotFound)

		    {

		    //pos = upper;

			User::Leave(KErrNotFound); 

		    //break;

		    }

		console->SetPos(i, 1);

		console->Printf(_L("%c"), (char)c);

		if(i%2)

		{

			upper = newDestMacAddr[i / 2];

			value = (TUint8)pos;

			//value = (TUint8)((upper<<4) | value);

			newDestMacAddr[i / 2] = (TUint8)((upper<<4) | value);

		}

		else

			newDestMacAddr[i / 2] = (TUint8)pos;

	}

	for(i = 0; i < 6; i++)

		DestMacAddr[i] = newDestMacAddr[i];

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

			 DestMacAddr[0], DestMacAddr[1], DestMacAddr[2],

			 DestMacAddr[3], DestMacAddr[4], DestMacAddr[5]);

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

	console->Getch();

   return; 

}

//-jk

void CDemoControl::StopL()

    {

    if(iIfState == EIdle)

		{

		User::Leave(KErrInUse);

		}

    EmptyWriteQueue();

#if (defined __USE_TIMER__)

    if(iIfState == EPump)

	{

		iTimer->Cancel();

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

		console->Printf(KMess,iPacketsWritten);

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

		console->Getch();

	}

#endif

    StopCard();

    iIfState = EIdle;

    }

void CDemoControl::StartCardL()

    {

//	User::LeaveIfError(iCard.Open(iCard.VersionRequired(),0,NULL));

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

    User::After(2000000);

//	TBuf8<8> ioctlBuf;

//	ioctlBuf.SetLength(1);

//	ioctlBuf[0] = KIoControlGetStatus;

//	TRequestStatus status;

//	iCard.IOControl(iStatus,ioctlBuf);

//	User::WaitForRequest(status);

//	if(ioctlBuf[0] != KEventPCCardReady)

//		{

//		iCard.Close();

//		User::Leave(KErrNotReady);

//		}

    // MAC Address starts at the 2nd byte

    iConfig.SetMax();

    iCard.Config(iConfig);

    iPacketsRead = 0;

    iPacketsWritten = 0;

    console->ClearScreen();

    }

void CDemoControl::StopCard()

    {

    iCard.ReadCancel();

    iCard.WriteCancel();

    iWriter->Cancel();

    iReader->Cancel();

    iCard.Close();

    }

void CDemoControl::ReadCompleteL(const TInt aStatus)

// Read completed by the server

    {

    iPacketsRead++;

    console->SetPos(0,1);

    _LIT(KMess,"Read  Complete Status = %d Packets Read    = %d\r\n");

    console->Printf(KMess,aStatus,iPacketsRead);

	RDebug::Print(KMess,aStatus,iPacketsRead);

    // Validate the received buffer with what we sent

    switch(iIfState)

	{

	case EPump:

	    HandleReadCompletePumpModeL();

	    break;

	case EEcho:

	    HandleReadCompleteEchoModeL();

	    break;

	case ERead:

	    HandleReadCompleteReadModeL();

	    break;

	case ESendAndCmpEcho:

		HandleReadCompleteSndCmpEchoModeL();

		break;

	default:

	    break;

	}

    iReadBuffer.SetMax();

    iReadBuffer.FillZ();

    iReader->ReadL(iReadBuffer);

    }

void CDemoControl::WriteCompleteL(const TInt aStatus)

// Write completed by the server

    {

    iPacketsWritten++;

    console->SetPos(0,0);

    _LIT(KMess,"Write Complete Status = %d Packets Written = %d\r\n");

    console->Printf(KMess,aStatus,iPacketsWritten);

    switch(iIfState)

	{

	case EPump:

	    HandleWriteCompletePumpModeL();

	    break;

	case EEcho:

	    HandleWriteCompleteEchoModeL();

	    break;

	case ESendAndCmpEcho:

			HandleWriteCompleteSndCmpEchoModeL();

			break;

	default:

	    break;

	}

    }

void CDemoControl::HandleWriteCompleteEchoModeL()

    {

    CIOBuffer* buf = iWriteQueue.First();

    iWriteQueue.Remove(*buf);

    delete buf;

    if(!iWriteQueue.IsEmpty())

	{

	buf = iWriteQueue.First();

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

	}

    }

void CDemoControl::HandleReadCompleteEchoModeL()

    // In echo mode we send out what we receive and there could potentialy be a write

    // outstanding.

    // Get a new CIOBuffer copy the read data to the new write buffer

    // Queue it but only WriteL() it if the queue was empty

    {

    TBool sendNow = EFalse;

    (iWriteQueue.IsEmpty()) ? (sendNow = ETrue) : (sendNow = EFalse);

    // Add it to the queue

    CIOBuffer* buf = CIOBuffer::NewL(iReadBuffer.Length());

    buf->Ptr() = iReadBuffer;

    // Flip Mac Addresses in buf

    FlipMacAddresses(buf->Ptr());

    iWriteQueue.AddLast(*buf);

    if(sendNow)

	{

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

	}

    }

void CDemoControl::FlipMacAddresses(TDes8& aBuf)

    {

    TUint32 length = aBuf.Length();

    aBuf.SetLength(6);

    TBuf8<6> dest(aBuf);

    aBuf.SetLength(12);

    aBuf.Copy(&aBuf[6],6);

    aBuf.SetLength(6);

    aBuf.Append(dest);

    aBuf.SetLength(length);

    }

void CDemoControl::HandleWriteCompletePumpModeL()

    // In pump mode we never need to queue so just reuse the last buffer

    {

#if (defined __USE_TIMER__)

    CIOBuffer* buf = iWriteQueue.First();

    iWriteQueue.Remove(*buf);

    delete buf;

#else

    CIOBuffer* buf = iWriteQueue.First();

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

#endif

    }

void CDemoControl::HandleReadCompletePumpModeL()

    {

    }

void CDemoControl::HandleReadCompleteReadModeL()

    {

    }

//////////////

CDemoWriter* CDemoWriter::NewL(MWriterNotify& aNotify,RBusDevEthernet& aCard)

// Standard CBase derived creation of the Writer object

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aNotify,aCard);

    CleanupStack::Pop();

    return self;

    }

void CDemoWriter::WriteL(const TDesC8& aBuffer)

// Write data to the server

    {

    // Sanity check on the state of the active object

    if(IsActive())

	{

#if (defined __USE_TIMER__)

	return;

#else

	User::Leave(KErrNotReady);

#endif

	}

    RDebug::Print(_L("About to write\n"));

    iCard->Write(iStatus,aBuffer);

    SetActive();

    }

CDemoWriter::~CDemoWriter()

    {

    // Just in case, does not hurt to call if object is not active

    Cancel();

    }

void CDemoWriter::ConstructL(MWriterNotify& aNotify,RBusDevEthernet& aCard)

// Second phase construction. Does not actually leave 

    {

    CActiveScheduler::Add(this);

    iNotify = &aNotify;

    iCard = &aCard;

    }

void CDemoWriter::RunL()

// Just call back into the parent to notify Write completion

    {

    // Pass the status

    iNotify->WriteCompleteL(iStatus.Int());

    }

void CDemoWriter::DoCancel()

// Called by the CActive base class Cancel()

// Only called if our TRequestStatus is still active 

    {

    }

///////

CDemoReader* CDemoReader::NewL(MReaderNotify& aNotify,RBusDevEthernet& aCard)

// Standard CBase derived creation of the Reader object

    {

    CDemoReader* self = new (ELeave) CDemoReader(EPriorityNormal+1);

    CleanupStack::PushL(self);

    self->ConstructL(aNotify,aCard);

    CleanupStack::Pop();

    return self;

    }

void CDemoReader::ReadL(TDes8& aBuffer)

    {

    // Sanity Check

    if(IsActive())

	{

	User::Leave(KErrNotReady);

	}

    RDebug::Print(_L("About to read\n"));

    iCard->Read(iStatus,aBuffer);

    SetActive();

    }

CDemoReader::~CDemoReader()

    {

    // Just in case, does not hurt to call if object is not active

    Cancel();

    }

void CDemoReader::ConstructL(MReaderNotify& aNotify,RBusDevEthernet& aCard)

// Second phase construction. Does not actually leave 

    {

    CActiveScheduler::Add(this);

    iNotify = &aNotify;

    iCard = &aCard;

    }

void CDemoReader::RunL()

// Just call back into the parent to notify read completion

    {

    // Pass the status

    iNotify->ReadCompleteL(iStatus.Int());

    }

void CDemoReader::DoCancel()

// Called by the CActive base class Cancel()

// Only called if our TRequestStatus is still active 

    {

    }

///////

static void DriveEngineL()

    {

    // Create an Active Scheduler for the thread

    // Only one Active Scheduler per thread

    CActiveScheduler* myActiveScheduler = new(ELeave) CActiveScheduler;

    CleanupStack::PushL(myActiveScheduler);

    // Install the Active Scheduler

    CActiveScheduler::Install(myActiveScheduler);

    // Create of program control class derived from CActive

    // The ConstructL() of CDemoControl adds itself to the Active Scheduler

    RDebug::Print(_L("New demo Cntrol\n"));

    CDemoControl* demo = CDemoControl::NewLC();

    // Request a character from the the console to kick the

    // Active scheduler into life. If this is not done then we will block on the

    // Scheduler loop semaphore forever.

    RDebug::Print(_L("demo Control request char\n"));

    demo->RequestCharacter();

    // Active scheduler now enters its control loop

    // We can exit this loop and hence the program by calling CActiveScheduler::Stop()

    // from a RunL().

    // IMPORTANT :-

    // From now on all this thread's processing takes place from the RunL()'s of

    // the Active objects that have been added to the Active Scheduler

    RDebug::Print(_L("Start scheduler\n"));

    myActiveScheduler->Start();

    // Remove and delete demo and myActiveScheduler

    CleanupStack::PopAndDestroy(2);	

    }

static void MainL()

    {

    // String Literal MACRO initialises a Descriptor

    //_LIT(KTitle,"EtherPump");

    //console=Console::NewL(KTitle,TSize(KDefaultConsWidth,KDefaultConsHeight));

    console=Console::NewL(_L("EtherPump"),TSize(KConsFullScreen,KConsFullScreen));

    RDebug::Print(_L("Console created\n"));

    CleanupStack::PushL(console);

    RDebug::Print(_L("and put on cu stack\n"));

    // TRAP

    TRAPD(err,DriveEngineL());

    if(err != KErrNone)

	{

	_LIT(KErrText,"Function Leave Code = %d\r\n");

	console->Printf(KErrText,err);

	}

    _LIT(KAnyKey,"Hit Any Key to Exit");

    console->ClearScreen();

    console->Printf(KAnyKey);

    console->Getch();

    CleanupStack::PopAndDestroy(1);

    }

// Entry point for all Epoc32 executables

// See PSP Chapter 2 Getting Started

GLDEF_C TInt E32Main()

    {

    // Heap balance checking

    // See PSP Chapter 6 Error Handling

    RDebug::Print(_L("create cu stack\n"));

    __UHEAP_MARK;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if(cleanup == NULL)

	{

	return KErrNoMemory;

	}

    RDebug::Print(_L("Run mainL\n"));

    TRAPD(err,MainL());