Why CPU overhead reach abnormal 100%???Strange!!!!!!!!!!!!!!

if(bFindAdapter)
return VGPDE_OK;
else
{
VGPDELOG(“Adapter not Found on this system!n”);
return VGPDEERRADAPTERNOTFOUND;
}
}

/////////////////////////////////////////////////////////////////////////////
//// VgPdeInvoke
//
// Purpose
//
// Parameters
//
// Return Value
//
// Remarks
//
VGPDE_STATUS VGPDEAPI VgPdeInvoke()
{
g_VgPdeContext.hThread = CreateThread(NULL, 0, PacketDispatchEngine, 0,
0, NULL);
if(!g_VgPdeContext.hThread)
return VGPDE_FAILURE;
return VGPDE_OK;
}

/////////////////////////////////////////////////////////////////////////////
//// PacketDispatchEngine
//
// Purpose
//
// Parameters
//
// Return Value
//
// Remarks
//

DWORD WINAPI PacketDispatchEngine(LPVOID pParam)
{
DWORD currentAdIdx = g_VgPdeContext.activeAdIndex;
HANDLE currentHandle = VgPdeGetAdapterHandleByIndex(currentAdIdx);
HANDLE activeHandle;
ether_header_ptr pEthHeader = NULL;
arphdr_ptr pArpHeader = NULL;
VG_PACKET_DESCRIPTOR pktDescriptor;

while(TRUE)
{
activeHandle = VgPdeGetActiveAdapterHandle();
if(currentHandle != activeHandle) // active adapter changed!!!
{
currentHandle = activeHandle; // point to current adapter

g_VgPdeContext.mode.hAdapterHandle = currentHandle;
g_VgPdeContext.rxReq.hAdapterHandle = currentHandle; // Hook rxReq with adapter
g_CNdisApi.SetPacketEvent(currentHandle, g_VgPdeContext.hEvent); // hook event with adapter
g_CNdisApi.SetAdapterMode(&g_VgPdeContext.mode); // set adapter mode
}

//
// Wait before active interface is ready to indicate the packet
//
WaitForSingleObject (g_VgPdeContext.hEvent, INFINITE);
ResetEvent(g_VgPdeContext.hEvent);

//
// Read packet from the interface until there are any
//
while(g_CNdisApi.ReadPacket(&g_VgPdeContext.rxReq))
{
//
// Get Ethernet header
//
pEthHeader = (ether_header_ptr)g_VgPdeContext.rxpktBuf.m_IBuffer;

// packet descriptor manipulation
pktDescriptor.nPktLen = g_VgPdeContext.rxpktBuf.m_Length; // frame length
pktDescriptor.pPktBuf = g_VgPdeContext.rxpktBuf.m_IBuffer; // full frame including ether header
if (g_VgPdeContext.rxpktBuf.m_dwDeviceFlags == PACKET_FLAG_ON_SEND)
pktDescriptor.ePktDirection = VG_PACKET_FROM_MSTCP;
else
pktDescriptor.ePktDirection = VG_PACKET_FROM_NIC;

//
// Check if Ethernet frame contains ARP packet
//
if(_ntohs(pEthHeader->h_proto) == ETH_P_ARP)
{
// packet type specified
pktDescriptor.ePktType = VG_PACKET_ARP;
//
// ARP packet handler callback
//
if(g_VgPdeContext.pktEvSets.pfnEvArpHandler != NULL)
g_VgPdeContext.pktEvSets.pfnEvArpHandler(&pktDescriptor);
}
else if(_ntohs(pEthHeader->h_proto) == ETH_P_IP)
{
// packet type specified
pktDescriptor.ePktType = VG_PACKET_IP;
//
// IP packet handler callback
//
if(g_VgPdeContext.pktEvSets.pfnEvIpHandler != NULL)
g_VgPdeContext.pktEvSets.pfnEvIpHandler(&pktDescriptor);
}
}
}

return 0;
}

/////////////////////////////////////////////////////////////////////////////
//// VgPdeTransmit
//
// Purpose
//
// Parameters
//
// Return Value
//
// Remarks
//
BOOL VGPDEAPI VgPdeTransmit(char *pPktBuf, int pktLength, VG_PACKET_DIRECTION eDirection)
{
if(NULL == pPktBuf)
return FALSE;

// Copy packet contents including ether header
memcpy(g_VgPdeContext.rxpktBuf.m_IBuffer, pPktBuf, pktLength);
// set packet length
g_VgPdeContext.rxpktBuf.m_Length = pktLength;

if(eDirection == VG_PACKET_TO_NIC)
return (g_CNdisApi.SendPacketToAdapter(&g_VgPdeContext.rxReq));
else
return (g_CNdisApi.SendPacketToMstcp(&g_VgPdeContext.rxReq));

}

/////////////////////////////////////////////////////////////////////////////
//// VgPdeForward
//
// Purpose
//
// Parameters
//
// Return Value
//
// Remarks
//
BOOL VGPDEAPI VgPdeForward(char *pPktBuf, int pktLength, unsigned char *pDestMac)
{
ether_header_ptr pEtherHdr = NULL;

return TRUE;
}

static void _PdeLog(PDE_LOG_LEVEL level,char *module,const char *fmt, …)
{

char buf[16];
const char *s;
int d;
va_list ap;
FILE * pLogFile = NULL;
char filename[MAX_PATH];

strcpy(filename,PDE_LOG_FILE);
pLogFile = fopen(filename,”a+”);
if(pLogFile == NULL)
return;

SYSTEMTIME sysTime;
GetSystemTime(&sysTime);

switch(level)
{
case PDE_LOG_LEVEL_INFO:
fprintf(pLogFile, “%d-%d-%d %d:%d:%d:%d : Information: %s:”, sysTime.wYear, sysTime.wMonth, sysTime.wDay,
sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds,module);
break;

case PDE_LOG_LEVEL_ERROR:
fprintf(pLogFile, “%d-%d-%d %d:%d:%d:%d : Error: %s:”, sysTime.wYear, sysTime.wMonth, sysTime.wDay,
sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds,module);
break;
case PDE_LOG_LEVEL_FATAL:
fprintf(pLogFile, “%d-%d-%d %d:%d:%d:%d : Fatal: %s:”, sysTime.wYear, sysTime.wMonth, sysTime.wDay,
sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds,module);
break;
default: break;
}

va_start(ap, fmt);
while (*fmt)
{
if (*fmt != ‘%’)
{
fputc(*fmt++,pLogFile);
continue;
}
switch (*++fmt)
{
case ‘s’:
case ‘S’:
s = va_arg(ap, const char *);
for ( ; *s; s++)
{
fputc(*s,pLogFile);
}
break;
case ‘d’:
case ‘D’:
d = va_arg(ap, int);
itoa(d, buf, 10);
for (s = buf; *s; s++)
{
fputc(*s,pLogFile);
}
break;
/* Add other specifiers here… */
case ‘x’:
case ‘X’:
d = va_arg(ap, int);
itoa(d, buf, 16);
for (s = buf; *s; s++)
{
fputc(*s,pLogFile);
}
break;

default:
fputc(*fmt,pLogFile);
break;
}
fmt++;
}
va_end(ap);
fprintf(pLogFile,”n”);
fclose(pLogFile);
}

Pde.h
====
#ifndef _PDE_H
#define _PDE_H

#include
#include
#include
#include

#define VG_PDE_NDIS_HOOKING // Upon NDIS-Hooking NdisRD driver
#ifdef VG_PDE_NDIS_HOOKING
#include “..NdisRdincludecommon.h”
#include “..NdisRdincludendisapi.h”
#endif

// The following ifdef block is the standard way of creating macros which make exporting
// from a DLL simpler. All files within this DLL are compiled with the PDE_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see
// PDE_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#ifdef PDE_EXPORTS
#define PDE_API __declspec(dllexport)
#else
#define PDE_API __declspec(dllimport)
#endif

#define VGPDEAPI WINAPI

#define VGPDE_DEBUG

#ifdef VGPDE_DEBUG
#define VGPDELOG(_x)
_PdeLog(PDE_LOG_LEVEL_ERROR, “Pde”, (_x))
#else
#define VGPDELOG(_x)
#endif

//#define ReleaseInterface VgPdeCleanup
#define _htons _ntohs

/*
* All PDE error constants are biased by VGPDEERRBASE from
* the “normal”
*/
#define VGPDEERRBASE 1000
#define VGPDEERRDRVNOTFOUND (VGPDEERRBASE + 1)
#define VGPDEERRNOTGETADAPTERS (VGPDEERRBASE + 2)
#define VGPDEERRADAPTERNOTFOUND (VGPDEERRBASE + 3)
#define VGPDEERRCREATEEVENT (VGPDEERRBASE + 4)

#define VGPDE_OK 0
#define VGPDE_FAILURE -1

#define PDE_LOG_FILE “..\bin\PdeLog.txt”

#pragma pack(1)

typedef enum _PDE_LOG_LEVEL
{
PDE_LOG_LEVEL_INFO = 0,
PDE_LOG_LEVEL_ERROR,
PDE_LOG_LEVEL_FATAL
}PDE_LOG_LEVEL;

typedef int VGPDE_STATUS;

typedef enum _VG_PACKET_TYPE // type of packet
{
VG_PACKET_ARP = 0,
VG_PACKET_IP
}VG_PACKET_TYPE;

typedef enum _VG_PACKET_DIRECTION // flow direction of packet
{
VG_PACKET_FROM_MSTCP,
VG_PACKET_FROM_NIC,
VG_PACKET_TO_MSTCP,
VG_PACKET_TO_NIC
}VG_PACKET_DIRECTION;

typedef UCHAR VG_PACKET_BUF, *PVG_PACKET_BUF;

typedef struct _VG_PACKET_DESCRIPTOR
{
VG_PACKET_TYPE ePktType;
VG_PACKET_DIRECTION ePktDirection;
PVG_PACKET_BUF pPktBuf;
UINT nPktLen;
}VG_PACKET_DESCRIPTOR, *PVG_PACKET_DESCRIPTOR;

typedef BOOL (*VG_PACKET_EVENT_HANDLER)(IN PVG_PACKET_DESCRIPTOR pPktDes);

typedef struct _VG_PACKET_EVENT_HANDLER_SET
{
VG_PACKET_EVENT_HANDLER pfnEvArpHandler; // for ARP packet
VG_PACKET_EVENT_HANDLER pfnEvIpHandler; // for IP packet
}VG_PACKET_EVENT_HANDLER_SET, *PVG_PACKET_EVENT_HANDLER_SET;

/* Core control data structure */
typedef struct _VG_PDE_CONTEXT
{
HANDLE hThread; // worker thread for packet event indication
TCP_AdapterList adList; // array of all adapters within system
DWORD activeAdIndex; // current active adapter
ADAPTER_MODE mode; // adapter working mode
ETH_REQUEST rxReq; // for packet reception
INTERMEDIATE_BUFFER rxpktBuf; // holding real packet contents for reception
ETH_REQUEST txReq; // for packet transmission
INTERMEDIATE_BUFFER txpktBuf; // holding real packet contents for transmission
HANDLE hEvent; // for event notification between pde and ndisrd driver
VG_PACKET_EVENT_HANDLER_SET pktEvSets;
}VG_PDE_CONTEXT, *PVG_PDE_CONTEXT;

// This class is exported from the Pde.dll
class PDE_API CPde
{
public:
CPde(void);
// TODO: add your methods here.
};

static USHORT _ntohs(USHORT netshort);
DWORD WINAPI PacketDispatchEngine(LPVOID pParam);
static void _PdeLog(PDE_LOG_LEVEL level,char *module,const char *fmt, …);

extern “C”
{
VGPDE_STATUS VGPDEAPI VgPdeStartup(unsigned char *pAdapterMac);
void VGPDEAPI VgPdeCleanup();
BOOL VGPDEAPI VgPdeRegister(PVG_PACKET_EVENT_HANDLER_SET pPktEvSet);
void VGPDEAPI VgPdeUnRegister();
HANDLE VGPDEAPI VgPdeGetActiveAdapterHandle();
HANDLE VGPDEAPI VgPdeGetAdapterHandleByIndex(DWORD adIdx);
VGPDE_STATUS VGPDEAPI VgPdeSetActiveAdapterHandle(unsigned char *pAdapterMac);
BOOL VGPDEAPI VgPdeTransmit(char *pPktBuf, int pktLength, VG_PACKET_DIRECTION eDirection);
BOOL VGPDEAPI VgPdeForward(char *pPktBuf, int pktLength, unsigned char *pDestMac);
};

#endif

Also here is PdeDemo.cpp which calls Pde.dll export routine.
=============================================
#include “stdafx.h”
#include “..Pde.h”
#include “..iphlp.h”

#define PdeDemoShow printf

unsigned char srcMac[] = {0x00, 0xC0, 0x9F, 0xF3, 0x45, 0x7A};
unsigned char dstMac[] = {0x00, 0x1C, 0xF0, 0x47, 0xBA, 0x38};

BOOL ArpHandler(IN PVG_PACKET_DESCRIPTOR pPktDes)
{
return TRUE;
}

BOOL IpHandler(IN PVG_PACKET_DESCRIPTOR pPktDes)
{
ether_header *pEthHdr = NULL;
iphdr *pIpHdr = NULL;

if (NULL == pPktDes)
return FALSE;

pEthHdr =(ether_header *)(pPktDes->pPktBuf);
pIpHdr = (iphdr *)(pPktDes->pPktBuf + sizeof(ether_header));

if(pPktDes->ePktDirection == VG_PACKET_FROM_NIC)
{
memcpy(pEthHdr->h_dest, dstMac, ETH_ALEN);
memcpy(pEthHdr->h_source, srcMac, ETH_ALEN);
if(!VgPdeTransmit((char *)pPktDes->pPktBuf,pPktDes->nPktLen,VG_PACKET_TO_NIC))
{
PdeDemoShow(“IpHandler@VgPdeTransmit errorn”);
return FALSE;
}
}
else /* from MSTCP */
{
if(!VgPdeTransmit((char *)pPktDes->pPktBuf,pPktDes->nPktLen,VG_PACKET_TO_NIC))
{
PdeDemoShow(“IpHandler@VgPdeTransmit errorn”);
return FALSE;
}
}

return TRUE;
}

int main(int argc, char* argv[])
{
VG_PACKET_EVENT_HANDLER_SET evHandlerSet;

PdeDemoShow(“nPde Demo Apploication v1.0.0(Build 20080107) is running ….n”);
PdeDemoShow(“Copyright(c)by SpeedVoIP Communication Technology Co., Ltd.n”);

memset(&evHandlerSet, 0, sizeof(evHandlerSet));
evHandlerSet.pfnEvArpHandler = ArpHandler;
evHandlerSet.pfnEvIpHandler = IpHandler;

VgPdeStartup(srcMac);
VgPdeRegister(&evHandlerSet);

while(1);