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

     _LIT(KPanic,"Etherpump");

     __ASSERT_ALWAYS(!err, User::Panic(KPanic,err));

     delete cleanup;

     __UHEAP_MARKEND;

     return KErrNone;

     }

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

 // Generic Buffer class

 // Currently used for transmit buffers

 CIOBuffer::CIOBuffer() : iBufPtr(NULL,0)

     {

     }

 CIOBuffer::~CIOBuffer()

 // Free the HBuf if there is one

     {

     FreeData();

     }

 TPtr8& CIOBuffer::Ptr()

     {

     return iBufPtr;

     }

 CIOBuffer* CIOBuffer::NewL(const TInt aSize)

 // Creation where we new the HBuf

     {

     CIOBuffer * self = new (ELeave) CIOBuffer;

     CleanupStack::PushL(self);

     self->ConstructL(aSize);

     CleanupStack::Pop();

     return self;

     }

 void CIOBuffer::ConstructL(const TInt aSize)

 // Construction where we new the HBuf

     {

     iBuf = HBufC8::NewL(aSize);

     TPtr8 temp=iBuf->Des();

     iBufPtr.Set(temp);

     }

 CIOBuffer* CIOBuffer::NewL(HBufC8* aBuf)

 // HBuf provided

     {

     CIOBuffer * self = new (ELeave) CIOBuffer;

     CleanupStack::PushL(self);

     self->ConstructL(aBuf);

     CleanupStack::Pop();

     return self;

     }

 void CIOBuffer::ConstructL(HBufC8* aBuffer)

     {

     Assign(aBuffer);

     }

 TInt CIOBuffer::LinkOffset()

     {

     return _FOFF(CIOBuffer,iLink);	

     }

 void CIOBuffer::Assign(HBufC8* aBuffer)

     {

     iBuf = aBuffer;

     if(aBuffer)

 	{

 	TPtr8 temp=iBuf->Des();

 	iBufPtr.Set(temp);

 	}

     }

 HBufC8*	CIOBuffer::Data() const

     {

     return iBuf;

     }

 void CIOBuffer::FreeData()

     {

     if(iBuf)

 	{

 	delete iBuf;

 	iBuf = NULL;

 	}

     }