纳闷了N天的一个菜鸟驱动问题

Question

怎么能使以下编译通过,就是想把这个NdisMSleep(1)加下去就是找不到头文件
纳闷了N天了......我是新手请各位路过的大哥帮下小弟....!!!//////////////////////////////////////////////////
// a.cpp文件#define NDIS50 1extern "C"
{
#include <ntddk.h>
#include <ndis.h>
}#pragma comment(lib,"ndis")// 驱动程序加载时调用DriverEntry例程
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
{
NdisMSleep(1);
// 请视情况返回DriverEntry例程执行结果
return STATUS_DEVICE_CONFIGURATION_ERROR;
}
编译时错误如下,还有加NdisMRegisterDevice这类中间层函数都是同样报错,但加协议驱动的函数没问题
是缺少了什么头文件?找了N天了还是搞不懂!!!
--------------------Configuration: a - Win32 Debug--------------------
Compiling...
a.cpp
E:\vc_code\a\a.cpp(17) : error C2065: 'NdisMSleep' : undeclared identifier
Error executing cl.exe.a.sys - 1 error(s), 0 warning(s)但在ndis.h中找到了这个函数的定义如下
EXPORT
VOID
NdisMSleep(
IN ULONG MicrosecondsToSleep
);

Answer 1

编译环境问题你用的WDK还是DDK 的？你用什么环境搭配？VC6.0+WDK 还是VS2005+DDK+DDKWISZAD????
我之前也遇到过这样的问题 

Answer 2

VC6.0+win2000ddk 但写协议驱动是没问题的,就象如下这个协议驱动编译是没问题的....
//////////////////////////////////////////////////
// ProtocolDriver.cpp文件
#define NDIS50 1extern "C"
{
#include <ntddk.h>
#include <ndis.h>
#include <stdio.h>
}#pragma comment(lib,"ndis")#define DEVICE_NAME L"\\Device\\devNdisProt"
#define LINK_NAME L"\\DosDevices\\slNdisProt"typedef struct _OPEN_INSTANCE
{
LIST_ENTRY AdapterListEntry;
PDEVICE_OBJECT pDeviceObj;
UNICODE_STRING ustrAdapterName;
UNICODE_STRING ustrLinkName;
NDIS_HANDLE hAdapter;
BOOLEAN bBound;
NDIS_STATUS Status;
ULONG nIrpCount;
NDIS_HANDLE hPacketPool;
LIST_ENTRY RcvList;
KSPIN_LOCK RcvSpinLock;
LIST_ENTRY ResetIrpList;
KSPIN_LOCK ResetQueueLock;
NDIS_EVENT BindEvent;
NDIS_EVENT CleanupEvent;
NDIS_MEDIUM Medium;
} OPEN_INSTANCE, *POPEN_INSTANCE;typedef struct _GLOBAL
{
PDRIVER_OBJECT pDriverObj;
NDIS_HANDLE hNdisProtocol;
LIST_ENTRY AdapterList;
KSPIN_LOCK GlobalLock;
PDEVICE_OBJECT pControlDevice;
}GLOBAL;typedef struct _PACKET_RESERVED
{
LIST_ENTRY ListElement;
PIRP pIrp;
PMDL pMdl;
}PACKET_RESERVED,*PPACKET_RESERVED;typedef struct _PROTOCOL_OID_DATA
{
    ULONG           Oid;
    ULONG           Length;
    UCHAR           Data[1];
} PROTOCOL_OID_DATA, *PPROTOCOL_OID_DATA;typedef struct _INTERNAL_REQUEST
{
PIRP pIrp;  
NDIS_REQUEST Request;
}INTERNAL_REQUEST, *PINTERNAL_REQUEST;

Answer 3

#define ETHERNET_HEADER_LENGTH 14
#define  MAX_LINK_NAME_LENGTH   124
#define RESERVED(_p) ((PACKET_RESERVED*)((_p)->ProtocolReserved))
#define FILE_DEVICE_PROTOCOL      0x8000
#define IOCTL_PROTOCOL_SET_OID      CTL_CODE(FILE_DEVICE_PROTOCOL, \
0 , METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PROTOCOL_QUERY_OID    CTL_CODE(FILE_DEVICE_PROTOCOL, \
1 , METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PROTOCOL_RESET        CTL_CODE(FILE_DEVICE_PROTOCOL, \
2 , METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_ENUM_ADAPTERS         CTL_CODE(FILE_DEVICE_PROTOCOL, \
3 , METHOD_BUFFERED, FILE_ANY_ACCESS)GLOBAL g_data;void IoIncrement(POPEN_INSTANCE pOpen);
void IoDecrement(POPEN_INSTANCE pOpen);
NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchRead(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchWrite(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchCleanup(PDEVICE_OBJECT pDevObj,PIRP pIrp);
NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj,PIRP pIrp);
void DriverUnload(PDRIVER_OBJECT pDriverObj);VOID ProtocolBindAdapter(OUT PNDIS_STATUS Status,
IN NDIS_HANDLE BindContext,
IN PNDIS_STRING DeviceName,
IN PVOID SystemSpecific1,
IN PVOID SystemSpecific2);VOID ProtocolUnbindAdapter(OUT PNDIS_STATUS Status,
  IN NDIS_HANDLE ProtocolBindingContext,
  IN NDIS_HANDLE UnbindContext);VOID ProtocolOpenAdapterComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_STATUS Status,
IN NDIS_STATUS OpenErrorStatus);VOID ProtocolCloseAdapterComplete(IN NDIS_HANDLE ProtocolBindingContext,
 IN NDIS_STATUS Status);NDIS_STATUS ProtocolReceive(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookAheadBufferSize,
IN UINT PacketSize);VOID ProtocolTransferDataComplete(IN NDIS_HANDLE ProtocolBindingContext,
 IN PNDIS_PACKET pPacket,
 IN NDIS_STATUS Status,
 IN UINT BytesTransfered);VOID ProtocolResetComplete(IN NDIS_HANDLE ProtocolBindingContext,
  IN NDIS_STATUS Status);VOID ProtocolRequestComplete(IN NDIS_HANDLE ProtocolBindingContext,
IN PNDIS_REQUEST NdisRequest,
IN NDIS_STATUS Status);VOID ProtocolSendComplete(IN NDIS_HANDLE ProtocolBindingContext,
 IN PNDIS_PACKET pPacket,
 IN NDIS_STATUS Status);VOID ProtocolStatus(IN NDIS_HANDLE ProtocolBindingContext,
   IN NDIS_STATUS Status,
   IN PVOID StatusBuffer,
   IN UINT StatusBufferSize);VOID ProtocolStatusComplete(IN NDIS_HANDLE ProtocolBindingContext);NDIS_STATUS ProtocolPNPHandler(IN NDIS_HANDLE ProtocolBindingContext,
   IN PNET_PNP_EVENT NetPnPEvent);VOID ProtocolReceiveComplete(IN NDIS_HANDLE ProtocolBindingContext);void CancelReadIrp(PDEVICE_OBJECT pDeviceObj);VOID ReadCancelRoutine(PDEVICE_OBJECT pDeviceObje,PIRP pIrp);NTSTATUS GetAdapterList(IN PVOID Buffer,IN ULONG Length,IN OUT PULONG DataLength);

Answer 4

// 驱动程序加载时调用DriverEntry例程
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_OBJECT pDeviceObj = NULL;
NDIS_STRING protoName = NDIS_STRING_CONST("Packet");
UNICODE_STRING ustrSymbolicLink;
BOOLEAN bSymbolicLink = FALSE;
DbgPrint(" ProtoDrv: DriverEntry...  \n");
g_data.pDriverObj = pDriverObj;
do
{
UNICODE_STRING ustrDevName;
RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);
status = IoCreateDevice(pDriverObj,
0,
&ustrDevName, 
FILE_DEVICE_UNKNOWN,
0,
FALSE,
&pDeviceObj);
if(!NT_SUCCESS(status))
{
DbgPrint(" ProtoDrv: CreateDevice failed \n");
break;
}
RtlInitUnicodeString(&ustrSymbolicLink, LINK_NAME);
status = IoCreateSymbolicLink(&ustrSymbolicLink, &ustrDevName);  
if(!NT_SUCCESS(status))
{
DbgPrint(" ProtoDrv: CreateSymbolicLink failed \n");
break;
}
bSymbolicLink = TRUE;
pDeviceObj->Flags |= DO_BUFFERED_IO;
g_data.pControlDevice = pDeviceObj;
InitializeListHead(&g_data.AdapterList);
KeInitializeSpinLock(&g_data.GlobalLock);
NDIS_PROTOCOL_CHARACTERISTICS protocolChar;
NdisZeroMemory(&protocolChar, sizeof(protocolChar));
protocolChar.Ndis40Chars.Ndis30Chars.MajorNdisVersion = 5;
protocolChar.Ndis40Chars.Ndis30Chars.MinorNdisVersion = 0;
protocolChar.Ndis40Chars.Ndis30Chars.Name = protoName;
protocolChar.Ndis40Chars.BindAdapterHandler = ProtocolBindAdapter;
protocolChar.Ndis40Chars.UnbindAdapterHandler = ProtocolUnbindAdapter;
protocolChar.Ndis40Chars.Ndis30Chars.OpenAdapterCompleteHandler  = ProtocolOpenAdapterComplete;
protocolChar.Ndis40Chars.Ndis30Chars.CloseAdapterCompleteHandler = ProtocolCloseAdapterComplete;
protocolChar.Ndis40Chars.Ndis30Chars.ReceiveHandler              = ProtocolReceive;
// protocolChar.Ndis40Chars.ReceivePacketHandler = ProtocolReceivePacket;
protocolChar.Ndis40Chars.Ndis30Chars.TransferDataCompleteHandler = ProtocolTransferDataComplete;
protocolChar.Ndis40Chars.Ndis30Chars.SendCompleteHandler         = ProtocolSendComplete;
protocolChar.Ndis40Chars.Ndis30Chars.ResetCompleteHandler        = ProtocolResetComplete;
protocolChar.Ndis40Chars.Ndis30Chars.RequestCompleteHandler      = ProtocolRequestComplete;
protocolChar.Ndis40Chars.Ndis30Chars.ReceiveCompleteHandler      = ProtocolReceiveComplete;
protocolChar.Ndis40Chars.Ndis30Chars.StatusHandler               = ProtocolStatus;
protocolChar.Ndis40Chars.Ndis30Chars.StatusCompleteHandler       = ProtocolStatusComplete;
protocolChar.Ndis40Chars.PnPEventHandler  = ProtocolPNPHandler;
NdisRegisterProtocol((PNDIS_STATUS)&status, 
&g_data.hNdisProtocol, &protocolChar, sizeof(protocolChar));
if(status != NDIS_STATUS_SUCCESS)
{
status = STATUS_UNSUCCESSFUL;
break;
}
DbgPrint(" ProtoDrv: NdisRegisterProtocol success \n");
pDriverObj->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
pDriverObj->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
pDriverObj->MajorFunction[IRP_MJ_READ]  = DispatchRead;
pDriverObj->MajorFunction[IRP_MJ_WRITE]  = DispatchWrite;
pDriverObj->MajorFunction[IRP_MJ_CLEANUP]  = DispatchCleanup;
pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;
pDriverObj->DriverUnload = DriverUnload;
status = STATUS_SUCCESS;
}while(FALSE);

if(!NT_SUCCESS(status))
{
if(pDeviceObj != NULL)
{
IoDeleteDevice(pDeviceObj); 
g_data.pControlDevice = NULL;
}
if(bSymbolicLink)
{
IoDeleteSymbolicLink(&ustrSymbolicLink);
}
}
return status;
}void DriverUnload(PDRIVER_OBJECT pDriverObj)
{
UNICODE_STRING ustrLink;
RtlInitUnicodeString(&ustrLink, LINK_NAME);
IoDeleteSymbolicLink(&ustrLink);
if(g_data.pControlDevice != NULL)
IoDeleteDevice(g_data.pControlDevice);
NDIS_STATUS status;
while(pDriverObj->DeviceObject != NULL)
{
ProtocolUnbindAdapter(&status, pDriverObj->DeviceObject->DeviceExtension, NULL);
}
NdisDeregisterProtocol(&status, g_data.hNdisProtocol);
}NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
DbgPrint(" ProtoDrv: DispatchClose \n");
NTSTATUS status = STATUS_SUCCESS;
if(pDevObj == g_data.pControlDevice)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)pDevObj->DeviceExtension;
IoIncrement(pOpen);
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
return status;
}NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
DbgPrint(" ProtoDrv: DispatchCreate \n");
NTSTATUS status = STATUS_SUCCESS;
if(pDevObj == g_data.pControlDevice)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)pDevObj->DeviceExtension;
IoIncrement(pOpen);
if(!pOpen->bBound)
{
status = STATUS_DEVICE_NOT_READY;
}
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
return status;
}NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
PVOID pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;
ULONG uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
ULONG uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
if(uIoControlCode == IOCTL_ENUM_ADAPTERS)
{
ULONG nDataLen = 0;
if(pDevObj != g_data.pControlDevice)
status = STATUS_INVALID_DEVICE_REQUEST;
else
{
status = GetAdapterList(pIoBuffer, uOutSize, &nDataLen);
if(status != STATUS_SUCCESS)
DbgPrint("GetAdapterList error ");
}
pIrp->IoStatus.Information = nDataLen;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return status;
}
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)pDevObj->DeviceExtension;
if(pOpen == NULL || !pOpen->bBound)
{
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
return STATUS_UNSUCCESSFUL;
}
IoIncrement(pOpen);
IoMarkIrpPending(pIrp);
if(uIoControlCode == IOCTL_PROTOCOL_RESET) 
{
       ExInterlockedInsertTailList(
                &pOpen->ResetIrpList,
                &pIrp->Tail.Overlay.ListEntry,
                &pOpen->ResetQueueLock);
        NdisReset(&status,
            pOpen->hAdapter
            );
        if(status != NDIS_STATUS_PENDING) 
{
            ProtocolResetComplete(
                pOpen,
                status);
        }
    }
else if(uIoControlCode == IOCTL_PROTOCOL_SET_OID 
|| uIoControlCode == IOCTL_PROTOCOL_QUERY_OID)
{
PPROTOCOL_OID_DATA pOidData = (PPROTOCOL_OID_DATA)pIoBuffer;
PINTERNAL_REQUEST pInterRequest = (PINTERNAL_REQUEST)ExAllocatePool(NonPagedPool, sizeof(INTERNAL_REQUEST));
   if(pInterRequest == NULL)
        {
            pIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
            IoCompleteRequest(pIrp, IO_NO_INCREMENT);
            IoDecrement(pOpen);
            return STATUS_PENDING;
        }
        pInterRequest->pIrp = pIrp;
if(uOutSize == uInSize && uOutSize >= sizeof(PROTOCOL_OID_DATA) &&
uOutSize >= sizeof(PROTOCOL_OID_DATA) - 1 + pOidData->Length)
{
if(uIoControlCode == IOCTL_PROTOCOL_SET_OID)
{
pInterRequest->Request.RequestType = NdisRequestSetInformation;
pInterRequest->Request.DATA.SET_INFORMATION.Oid = pOidData->Oid;
pInterRequest->Request.DATA.SET_INFORMATION.InformationBuffer = pOidData->Data;
pInterRequest->Request.DATA.SET_INFORMATION.InformationBufferLength = pOidData->Length;
}
else
{
pInterRequest->Request.RequestType = NdisRequestQueryInformation;
pInterRequest->Request.DATA.QUERY_INFORMATION.Oid = pOidData->Oid;
pInterRequest->Request.DATA.QUERY_INFORMATION.InformationBuffer = pOidData->Data;
pInterRequest->Request.DATA.QUERY_INFORMATION.InformationBufferLength = pOidData->Length;
}
NdisRequest(&status, pOpen->hAdapter, &pInterRequest->Request);
}
else
{
status = NDIS_STATUS_FAILURE;
            pInterRequest->Request.DATA.SET_INFORMATION.BytesRead = 0;
            pInterRequest->Request.DATA.QUERY_INFORMATION.BytesWritten = 0;
}
if(status != NDIS_STATUS_PENDING)
{
ProtocolRequestComplete(pOpen, &pInterRequest->Request, status);
}
}
return STATUS_PENDING;
}

Answer 5

VOID
ProtocolResetComplete(
    IN NDIS_HANDLE  ProtocolBindingContext,
    IN NDIS_STATUS  Status
    ){
OPEN_INSTANCE *pOpen;
    pOpen = (OPEN_INSTANCE*)ProtocolBindingContext;
PLIST_ENTRY pListEntry = ExInterlockedRemoveHeadList(&pOpen->ResetIrpList,
                       &pOpen->ResetQueueLock);
    PIRP pIrp = CONTAINING_RECORD(pListEntry,IRP,Tail.Overlay.ListEntry);
    if(Status == NDIS_STATUS_SUCCESS) 
{
        pIrp->IoStatus.Status = STATUS_SUCCESS;
    } 
else 
{
        pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
    }
    pIrp->IoStatus.Information = 0;    
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    IoDecrement(pOpen);
}VOID
ProtocolRequestComplete(IN NDIS_HANDLE   ProtocolBindingContext,
   IN PNDIS_REQUEST NdisRequest,
   IN NDIS_STATUS   Status)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)ProtocolBindingContext;
PINTERNAL_REQUEST pInterRequest = CONTAINING_RECORD(NdisRequest, INTERNAL_REQUEST, Request);
PIRP pIrp = pInterRequest->pIrp;
if(Status == NDIS_STATUS_SUCCESS)
{
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
UINT nIoControlCode = pIrpSp->Parameters.DeviceIoControl.IoControlCode;
PPROTOCOL_OID_DATA pOidData = (PPROTOCOL_OID_DATA)pIrp->AssociatedIrp.SystemBuffer;
        if(nIoControlCode == IOCTL_PROTOCOL_SET_OID) 
{
            pOidData->Length = pInterRequest->Request.DATA.SET_INFORMATION.BytesRead;
        } 
else if(nIoControlCode == IOCTL_PROTOCOL_QUERY_OID) 
{
pOidData->Length = pInterRequest->Request.DATA.QUERY_INFORMATION.BytesWritten;
}
pIrp->IoStatus.Information = pIrpSp->Parameters.DeviceIoControl.InputBufferLength;
pIrp->IoStatus.Status = STATUS_SUCCESS;
}
else
{
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
}
ExFreePool(pInterRequest);
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}NTSTATUS
GetAdapterList(IN  PVOID              Buffer,
   IN  ULONG              Length,
   IN  OUT PULONG         DataLength)
{
KIRQL oldIrql;
KeAcquireSpinLock(&g_data.GlobalLock, &oldIrql);
OPEN_INSTANCE *pOpen ;
ULONG nRequiredLength = 0;
ULONG nAdapters = 0;
PLIST_ENTRY pThisEntry;
PLIST_ENTRY pHeader = &g_data.AdapterList;
for(pThisEntry = pHeader->Flink ; pThisEntry != pHeader; pThisEntry = pThisEntry->Flink)
{
pOpen = CONTAINING_RECORD(pThisEntry, OPEN_INSTANCE, AdapterListEntry);
nRequiredLength += pOpen->ustrAdapterName.Length + sizeof(UNICODE_NULL);
nRequiredLength += pOpen->ustrLinkName.Length + sizeof(UNICODE_NULL);
nAdapters++;
}
nRequiredLength += sizeof(nAdapters) + sizeof(UNICODE_NULL); 
*DataLength = nRequiredLength;
if(nRequiredLength > Length)
{
        KeReleaseSpinLock(&g_data.GlobalLock, oldIrql);
        return STATUS_BUFFER_TOO_SMALL;
    }
*(PULONG)Buffer = nAdapters;
Buffer = (PCHAR)Buffer + sizeof(ULONG);
for(pThisEntry = pHeader->Flink; 
pThisEntry != pHeader;
pThisEntry = pThisEntry->Flink)
    {
        pOpen = CONTAINING_RECORD(pThisEntry, OPEN_INSTANCE, AdapterListEntry);
        RtlCopyMemory(Buffer, pOpen->ustrAdapterName.Buffer,
                            pOpen->ustrAdapterName.Length + sizeof(WCHAR));
Buffer = (PCHAR)Buffer + pOpen->ustrAdapterName.Length + sizeof(WCHAR);
        RtlCopyMemory(Buffer, pOpen->ustrLinkName.Buffer,
                            pOpen->ustrLinkName.Length + sizeof(WCHAR));
Buffer = (PCHAR)Buffer + pOpen->ustrLinkName.Length + sizeof(WCHAR);                       
    }
    *(PWCHAR)Buffer = UNICODE_NULL;
    KeReleaseSpinLock(&g_data.GlobalLock, oldIrql);
return STATUS_SUCCESS;
}void IoIncrement(OPEN_INSTANCE *pOpen)
{
if(InterlockedIncrement((PLONG)&pOpen->nIrpCount) == 1)
NdisResetEvent(&pOpen->CleanupEvent);
}void IoDecrement(OPEN_INSTANCE *pOpen)
{
if(InterlockedDecrement((PLONG)&pOpen->nIrpCount) == 0)
NdisSetEvent(&pOpen->CleanupEvent);
}NTSTATUS
DispatchCleanup(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
    POPEN_INSTANCE      pOpen = (POPEN_INSTANCE)DeviceObject->DeviceExtension;
    NTSTATUS            status = STATUS_SUCCESS;
    if(DeviceObject == g_data.pControlDevice) 
{
        Irp->IoStatus.Status = status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;
    }
    IoIncrement(pOpen);
    CancelReadIrp(DeviceObject);
    IoDecrement(pOpen);
    NdisWaitEvent(&pOpen->CleanupEvent, 0);
    Irp->IoStatus.Information = 0;    
    Irp->IoStatus.Status = status;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);
    return status;
}
VOID
ProtocolStatus(IN NDIS_HANDLE   ProtocolBindingContext,
   IN NDIS_STATUS   Status,
   IN PVOID         StatusBuffer,
   IN UINT          StatusBufferSize)
{
}VOID
ProtocolStatusComplete(IN NDIS_HANDLE  ProtocolBindingContext)
{
}NDIS_STATUS
ProtocolPNPHandler(IN    NDIS_HANDLE        ProtocolBindingContext,
   IN    PNET_PNP_EVENT     NetPnPEvent)
{
    NDIS_STATUS                 Status  = NDIS_STATUS_SUCCESS;
    PNET_DEVICE_POWER_STATE     powerState;
    powerState = (PNET_DEVICE_POWER_STATE)NetPnPEvent->Buffer;
    switch(NetPnPEvent->NetEvent)
    {
         case  NetEventSetPower :
            switch (*powerState) 
{
                case NetDeviceStateD0:
                    Status = NDIS_STATUS_SUCCESS;
                    break;
                default:
                    Status = NDIS_STATUS_NOT_SUPPORTED;
                    break;
            }
    }
    return Status;
}VOID
ProtocolBindAdapter(OUT PNDIS_STATUS Status,
IN NDIS_HANDLE  BindContext,
IN PNDIS_STRING  DeviceName,
IN PVOID  SystemSpecific1,
IN PVOID  SystemSpecific2)
{ DbgPrint(" ProtoDrv: ProtocolBindAdapter... \n");
NDIS_STATUS status = STATUS_SUCCESS;
PDEVICE_OBJECT pDeviceObj = NULL;
UNICODE_STRING ustrDevName = { 0 };
OPEN_INSTANCE *pOpen = NULL;
do
{
int nLen = DeviceName->Length + 7*sizeof(WCHAR) + sizeof(UNICODE_NULL);
PWSTR strName = (PWSTR)ExAllocatePool(NonPagedPool, nLen);
if(strName == NULL)
{
*Status = NDIS_STATUS_FAILURE;
break;
}
swprintf(strName, L"\\Device\\Packet_%ws", &DeviceName->Buffer[8]);
RtlInitUnicodeString(&ustrDevName, strName);
status = IoCreateDevice(g_data.pDriverObj,
sizeof(OPEN_INSTANCE),
&ustrDevName,
FILE_DEVICE_PROTOCOL,
0,
TRUE,
&pDeviceObj);
if(status != STATUS_SUCCESS)
{
DbgPrint(" ProtoDrv: CreateDevice() failed \n ");
*Status = NDIS_STATUS_FAILURE; 
break;
}
pDeviceObj->Flags |= DO_DIRECT_IO;
pOpen = (OPEN_INSTANCE*)pDeviceObj->DeviceExtension;
pOpen->pDeviceObj = pDeviceObj;
nLen = ustrDevName.Length + 4*sizeof(WCHAR) + sizeof(UNICODE_NULL);
strName = (PWSTR)ExAllocatePool(NonPagedPool, nLen);
if(strName == NULL)
{
*Status = NDIS_STATUS_FAILURE;
break;
}
swprintf(strName, L"\\DosDevices\\%ws", &ustrDevName.Buffer[8]);
RtlInitUnicodeString(&pOpen->ustrLinkName, strName);
status = IoCreateSymbolicLink(&pOpen->ustrLinkName, &ustrDevName); 
if(status != STATUS_SUCCESS)
{
*Status = NDIS_STATUS_FAILURE;
DbgPrint(" ProtoDrv: Create symbolic failed \n");
break;
}
ExFreePool(ustrDevName.Buffer);
ustrDevName.Buffer = NULL;
NdisAllocatePacketPool(&status, 
&pOpen->hPacketPool, 16, sizeof(PACKET_RESERVED));
if(status != NDIS_STATUS_SUCCESS)
{
*Status = NDIS_STATUS_FAILURE;
break;
}
NdisInitializeEvent(&pOpen->BindEvent);
InitializeListHead(&pOpen->ResetIrpList);
KeInitializeSpinLock(&pOpen->ResetQueueLock);
InitializeListHead(&pOpen->RcvList);
KeInitializeSpinLock(&pOpen->RcvSpinLock);
NDIS_MEDIUM         mediumArray = NdisMedium802_3;
UINT mediumIndex;
NdisOpenAdapter(Status,
&status,
&pOpen->hAdapter,
&mediumIndex,
&mediumArray,
sizeof(mediumArray)/sizeof(NDIS_MEDIUM),
g_data.hNdisProtocol,
pOpen,
DeviceName,
0,
NULL);
if(*Status == NDIS_STATUS_PENDING)
        {
              NdisWaitEvent(&pOpen->BindEvent, 0);
              *Status = pOpen->Status;
        }
if(*Status != NDIS_STATUS_SUCCESS)
{
DbgPrint(" ProtoDrv: OpenAdapter failed! \n");
break;
}
pOpen->nIrpCount = 0;
InterlockedExchange((PLONG)&pOpen->bBound, TRUE);
NdisInitializeEvent(&pOpen->CleanupEvent);
NdisSetEvent(&pOpen->CleanupEvent);
NdisQueryAdapterInstanceName(&pOpen->ustrAdapterName, pOpen->hAdapter);
pOpen->Medium = mediumArray;
InitializeListHead(&pOpen->AdapterListEntry);
        ExInterlockedInsertTailList(&g_data.AdapterList,
&pOpen->AdapterListEntry,
&g_data.GlobalLock);
pDeviceObj->Flags &= ~DO_DEVICE_INITIALIZING;
} 
while(FALSE);
if(*Status != NDIS_STATUS_SUCCESS)
{
 if(pOpen != NULL && pOpen->hPacketPool != NULL) 
 {
             NdisFreePacketPool(pOpen->hPacketPool);
 }
 if(pDeviceObj != NULL)
 IoDeleteDevice(pDeviceObj);
 if(ustrDevName.Buffer != NULL)
 ExFreePool(ustrDevName.Buffer);
 if(pOpen->ustrLinkName.Buffer != NULL)
 {
IoDeleteSymbolicLink(&pOpen->ustrLinkName);
ExFreePool(pOpen->ustrLinkName.Buffer);
 }
}
}

Answer 6

VOID
ProtocolOpenAdapterComplete(IN NDIS_HANDLE  ProtocolBindingContext,
IN NDIS_STATUS  Status,
IN NDIS_STATUS  OpenErrorStatus)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)ProtocolBindingContext;
pOpen->Status = Status;
    NdisSetEvent(&pOpen->BindEvent);
}VOID
ProtocolUnbindAdapter(OUT PNDIS_STATUS  Status,
  IN NDIS_HANDLE  ProtocolBindingContext,
  IN NDIS_HANDLE  UnbindContext)
{ 
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
if(pOpen->hAdapter != NULL)
{
NdisResetEvent(&pOpen->BindEvent);
InterlockedExchange((PLONG)&pOpen->bBound, FALSE);
CancelReadIrp(pOpen->pDeviceObj);
NdisWaitEvent(&pOpen->CleanupEvent, 0);
NdisCloseAdapter(Status, pOpen->hAdapter);
if(*Status == NDIS_STATUS_PENDING)
        {
            NdisWaitEvent(&pOpen->BindEvent, 0);
            *Status = pOpen->Status;
        }
        else
        {
            *Status = NDIS_STATUS_FAILURE;
        }
KIRQL oldIrql;
KeAcquireSpinLock(&g_data.GlobalLock, &oldIrql); 
        RemoveEntryList(&pOpen->AdapterListEntry);
        KeReleaseSpinLock(&g_data.GlobalLock, oldIrql);
        NdisFreePacketPool(pOpen->hPacketPool);
        NdisFreeMemory(pOpen->ustrAdapterName.Buffer, pOpen->ustrAdapterName.Length, 0);
        IoDeleteSymbolicLink(&pOpen->ustrLinkName);
        ExFreePool(pOpen->ustrLinkName.Buffer);
        IoDeleteDevice(pOpen->pDeviceObj);
}
}VOID 
  ProtocolCloseAdapterComplete(IN NDIS_HANDLE  ProtocolBindingContext,
  IN NDIS_STATUS  Status)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)ProtocolBindingContext;
pOpen->Status = Status;
    NdisSetEvent(&pOpen->BindEvent);
}NTSTATUS DispatchRead(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
NTSTATUS status = STATUS_SUCCESS;
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)pDevObj->DeviceExtension;
IoIncrement(pOpen);
do
{
if(!pOpen->bBound)
{
status = STATUS_DEVICE_NOT_READY;
break;
}
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation(pIrp);
if(irpSp->Parameters.Read.Length < ETHERNET_HEADER_LENGTH)
{
status = STATUS_BUFFER_TOO_SMALL;
break;
}
PNDIS_PACKET pPacket;
NdisAllocatePacket((PNDIS_STATUS)&status, &pPacket, pOpen->hPacketPool);
if(status != NDIS_STATUS_SUCCESS)
{
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RESERVED(pPacket)->pIrp = pIrp;
RESERVED(pPacket)->pMdl = NULL;
IoMarkIrpPending(pIrp);
IoSetCancelRoutine(pIrp, ReadCancelRoutine);
ExInterlockedInsertTailList(&pOpen->RcvList,
&RESERVED(pPacket)->ListElement, &pOpen->RcvSpinLock);
return STATUS_PENDING;
}while(FALSE);
if(status != STATUS_SUCCESS)
{
IoDecrement(pOpen);
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}VOID
ReadCancelRoutine (IN PDEVICE_OBJECT   pDeviceObject,
   IN PIRP             pIrp)
{
POPEN_INSTANCE pOpen = (POPEN_INSTANCE)pDeviceObject->DeviceExtension;
NDIS_PACKET *pPacket = NULL;
KIRQL oldIrql = pIrp->CancelIrql;
KeAcquireSpinLockAtDpcLevel(&pOpen->RcvSpinLock);
IoReleaseCancelSpinLock(KeGetCurrentIrql());
PLIST_ENTRY pThisEntry = NULL;
PACKET_RESERVED *pReserved;
PLIST_ENTRY pHead = &pOpen->RcvList;
for(pThisEntry = pHead->Flink; pThisEntry != pHead;  pThisEntry = pThisEntry->Flink)
{
pReserved = CONTAINING_RECORD(pThisEntry, PACKET_RESERVED, ListElement);
if(pReserved->pIrp == pIrp)
{
RemoveEntryList(pThisEntry);
pPacket = CONTAINING_RECORD(pReserved, NDIS_PACKET, ProtocolReserved);
break;
}
}
KeReleaseSpinLock(&pOpen->RcvSpinLock, oldIrql);
if(pPacket != NULL)
{
NdisFreePacket(pPacket);
pIrp->IoStatus.Status = STATUS_CANCELLED;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}
}void CancelReadIrp(PDEVICE_OBJECT pDeviceObj)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)pDeviceObj->DeviceExtension;
PLIST_ENTRY thisEntry;
PACKET_RESERVED *reserved;
PNDIS_PACKET myPacket;
PIRP pPendingIrp;
while(thisEntry = ExInterlockedRemoveHeadList(&pOpen->RcvList, &pOpen->RcvSpinLock))
{
reserved = CONTAINING_RECORD(thisEntry, PACKET_RESERVED, ListElement);
myPacket = CONTAINING_RECORD(reserved, NDIS_PACKET, ProtocolReserved);
pPendingIrp = RESERVED(myPacket)->pIrp;
NdisFreePacket(myPacket);
IoSetCancelRoutine(pPendingIrp, NULL);
pPendingIrp->IoStatus.Information = 0;
pPendingIrp->IoStatus.Status = STATUS_CANCELLED;
IoCompleteRequest(pPendingIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}
}NDIS_STATUS
ProtocolReceive(IN NDIS_HANDLE ProtocolBindingContext,
IN NDIS_HANDLE MacReceiveContext,
IN PVOID       HeaderBuffer,
IN UINT        HeaderBufferSize,
IN PVOID       LookAheadBuffer,
IN UINT        LookaheadBufferSize,
IN UINT        PacketSize)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
if(HeaderBufferSize > ETHERNET_HEADER_LENGTH)
{
return NDIS_STATUS_SUCCESS;
}
PLIST_ENTRY pListEntry = ExInterlockedRemoveHeadList(&pOpen->RcvList, &pOpen->RcvSpinLock);
if(pListEntry == NULL)
{
return NDIS_STATUS_NOT_ACCEPTED;
}
PACKET_RESERVED *pReserved = CONTAINING_RECORD(pListEntry, PACKET_RESERVED, ListElement);
NDIS_PACKET *pPacket = CONTAINING_RECORD(pReserved, NDIS_PACKET, ProtocolReserved);
PIRP pIrp = RESERVED(pPacket)->pIrp;
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
IoSetCancelRoutine(pIrp, NULL);
NdisMoveMappedMemory(MmGetSystemAddressForMdlSafe(pIrp->MdlAddress, NormalPagePriority), 
HeaderBuffer, HeaderBufferSize);
UINT nBufferLen = pIrpSp->Parameters.Read.Length - HeaderBufferSize;
UINT nSizeToTransfer = nBufferLen < LookaheadBufferSize ? nBufferLen : LookaheadBufferSize;
NDIS_STATUS status;
PMDL pMdl = IoAllocateMdl(MmGetMdlVirtualAddress(pIrp->MdlAddress),
MmGetMdlByteCount(pIrp->MdlAddress), FALSE, FALSE, NULL);
if(pMdl == NULL) 
{
        status = NDIS_STATUS_RESOURCES;
        goto ERROR;
}
    IoBuildPartialMdl(
        pIrp->MdlAddress,
        pMdl,
        ((PUCHAR)MmGetMdlVirtualAddress(pIrp->MdlAddress)) + ETHERNET_HEADER_LENGTH,
        0
        );
    pMdl->Next=NULL;
    RESERVED(pPacket)->pMdl = pMdl;
    NdisChainBufferAtFront(pPacket,pMdl);
UINT nBytesTransfered;
    NdisTransferData(&status,
pOpen->hAdapter,
        MacReceiveContext,
        0,
        nSizeToTransfer,
        pPacket,
        &nBytesTransfered);
    if(status == NDIS_STATUS_PENDING) 
{
        return NDIS_STATUS_SUCCESS;
    }
ERROR:
    ProtocolTransferDataComplete(pOpen,
pPacket,
status,
nBytesTransfered);
    return NDIS_STATUS_SUCCESS;
}

Answer 7

VOID
ProtocolTransferDataComplete (IN NDIS_HANDLE   ProtocolBindingContext,
  IN PNDIS_PACKET  pPacket,
  IN NDIS_STATUS   Status,
  IN UINT          BytesTransfered)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
PMDL pMdl = RESERVED(pPacket)->pMdl;
PIRP pIrp = RESERVED(pPacket)->pIrp;
if(pMdl != NULL)
IoFreeMdl(pMdl);
NdisFreePacket(pPacket);
if(Status == NDIS_STATUS_SUCCESS)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = BytesTransfered + ETHERNET_HEADER_LENGTH;
}
else
{
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
pIrp->IoStatus.Information = 0;
}
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}
VOID
ProtocolReceiveComplete(IN NDIS_HANDLE  ProtocolBindingContext)
{
}/*
int ProtocolReceivePacket(NDIS_HANDLE ProtocolBindingContext, PNDIS_PACKET Packet)
{
DbgPrint("ProtocolReceivePacket \n");
UINT nBufferLen;
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
PLIST_ENTRY pListEntry = ExInterlockedRemoveHeadList(&pOpen->RcvList, &pOpen->RcvSpinLock);
if(pListEntry == NULL)
{
return 0;
}
PACKET_RESERVED *pReserved = CONTAINING_RECORD(pListEntry, PACKET_RESERVED, ListElement);
NDIS_PACKET *pPacket = CONTAINING_RECORD(pReserved, NDIS_PACKET, ProtocolReserved);
PIRP pIrp = RESERVED(pPacket)->pIrp;
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
IoSetCancelRoutine(pIrp, NULL);
NTSTATUS status = STATUS_SUCCESS;
{
PNDIS_BUFFER firstBuffer, nextBuffer;
UINT totalLength;
PVOID virtualAddress;
NdisQueryPacket(pPacket, NULL, NULL, &firstBuffer, &totalLength);
while(firstBuffer != NULL)
{
NdisQueryBufferSafe(firstBuffer, &virtualAddress, &totalLength, NormalPagePriority);
if(virtualAddress == NULL)
{
status = STATUS_INSUFFICIENT_RESOURCES;
goto CleanExit;
}
NdisGetNextBuffer(firstBuffer, &nextBuffer);
firstBuffer = nextBuffer;
}
}
NdisChainBufferAtFront(pPacket, pIrp->MdlAddress);
nBufferLen = pIrpSp->Parameters.Read.Length;
UINT nTransfered;
NdisCopyFromPacketToPacket(pPacket, 0, nBufferLen,Packet,0,&nTransfered);
CleanExit:
pIrp->IoStatus.Information = nTransfered;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
return 0;
}
*/NTSTATUS DispatchWrite(PDEVICE_OBJECT pDevObj, PIRP pIrp)
{
NTSTATUS status;
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)pDevObj->DeviceExtension;
IoIncrement(pOpen);
do
{
if(!pOpen->bBound)
{
status = STATUS_DEVICE_NOT_READY;
break;
}
PNDIS_PACKET pPacket;
NdisAllocatePacket((NDIS_STATUS*)&status, &pPacket, pOpen->hPacketPool);
if(status != NDIS_STATUS_SUCCESS)
{
status = STATUS_INSUFFICIENT_RESOURCES;
break;
}
RESERVED(pPacket)->pIrp = pIrp;
NdisChainBufferAtFront(pPacket, pIrp->MdlAddress);
IoMarkIrpPending(pIrp);
NdisSend((NDIS_STATUS*)&status, pOpen->hAdapter, pPacket);
if(status != NDIS_STATUS_PENDING)
{
ProtocolSendComplete(pOpen, pPacket, status);
}
return STATUS_PENDING;
}while(FALSE);
if(status != STATUS_SUCCESS)
{
IoDecrement(pOpen);
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}
VOID
ProtocolSendComplete(IN NDIS_HANDLE   ProtocolBindingContext,
 IN PNDIS_PACKET  pPacket,
 IN NDIS_STATUS   Status)
{
OPEN_INSTANCE *pOpen = (OPEN_INSTANCE *)ProtocolBindingContext;
PIRP pIrp = RESERVED(pPacket)->pIrp;
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation(pIrp);
NdisFreePacket(pPacket);
if(Status == NDIS_STATUS_SUCCESS)
{
pIrp->IoStatus.Information = pIrpSp->Parameters.Write.Length;
pIrp->IoStatus.Status = STATUS_SUCCESS;
DbgPrint(" ProtoDrv: Send data success \n");
}
else
{
pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = STATUS_UNSUCCESSFUL;
}
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
IoDecrement(pOpen);
}怎么协议驱动能编译怎么就是写中间层驱动的函数就不行的呢是VC6.0+win2000ddk怎么配环境变量?

Answer 8

你试试把VC6.0编译环境的DDK路径提前到6.0自己的库前面再编译