驅動程式 - Windows NT Driver (Legacy) - 使用範例 - C/C++ (DDK) - Queue IRP

參考資訊：
https://wasm.in/
http://four-f.narod.ru/
https://github.com/steward-fu/ddk
http://www.delphibasics.info/home/delphibasicsprojects/delphidriverdevelopmentkit

main.c

#include <ntddk.h>
 
#define IOCTL_QUEUE   CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
 
#define DEV_NAME L"\\Device\\MyDriver"
#define SYM_NAME L"\\DosDevices\\MyDriver"
 
KTIMER stTime = { 0};
KDPC stTimeDPC = { 0 };
LIST_ENTRY stQueue = { 0 };
 
VOID OnTimer(struct _KDPC *Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
{
    PIRP pIrp = NULL;
    PLIST_ENTRY plist = NULL;

    if (IsListEmpty(&stQueue) == TRUE) {
        KeCancelTimer(&stTime);
        DbgPrint("Finish");
    }
    else{
        plist = RemoveHeadList(&stQueue);
        pIrp = CONTAINING_RECORD(plist, IRP, Tail.Overlay.ListEntry);
        pIrp->IoStatus.Status = STATUS_SUCCESS;
        pIrp->IoStatus.Information = 0;
        IoCompleteRequest(pIrp, IO_NO_INCREMENT);
        DbgPrint("Complete Irp");
    }
}
 
void Unload(PDRIVER_OBJECT pMyDriver)
{
    UNICODE_STRING usSymboName = { 0 };
                                
    RtlInitUnicodeString(&usSymboName, L"\\DosDevices\\MyDriver");
    IoDeleteSymbolicLink(&usSymboName);
    IoDeleteDevice(pMyDriver->DeviceObject);
}
 
NTSTATUS IrpIOCTL(PDEVICE_OBJECT pMyDevice, PIRP pIrp)
{
    LARGE_INTEGER stTimePeriod = { 0 };
    PIO_STACK_LOCATION psk = IoGetCurrentIrpStackLocation(pIrp);
 
    switch (psk->Parameters.DeviceIoControl.IoControlCode) {
    case IOCTL_QUEUE:
        DbgPrint("IOCTL_QUEUE");

        InsertHeadList(&stQueue, &pIrp->Tail.Overlay.ListEntry);
        IoMarkIrpPending(pIrp);
        return STATUS_PENDING;
    case IOCTL_PROCESS:
        DbgPrint("IOCTL_PROCESS");

        stTimePeriod.HighPart |= -1;
        stTimePeriod.LowPart = -10000000;
        KeSetTimerEx(&stTime, stTimePeriod, 10, &stTimeDPC);
        break;
    }
    pIrp->IoStatus.Information = 0;
    pIrp->IoStatus.Status = STATUS_SUCCESS;
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}
 
NTSTATUS IrpFile(PDEVICE_OBJECT pMyDevice, PIRP pIrp)
{
    PIO_STACK_LOCATION psk = IoGetCurrentIrpStackLocation(pIrp);
 
    switch (psk->MajorFunction) {
    case IRP_MJ_CREATE:
        DbgPrint("IRP_MJ_CREATE");
        break;
    case IRP_MJ_CLOSE:
        DbgPrint("IRP_MJ_CLOSE");
        break;
    }
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    return STATUS_SUCCESS;
}
 
NTSTATUS DriverEntry(PDRIVER_OBJECT pMyDriver, PUNICODE_STRING pMyRegistry)
{
    PDEVICE_OBJECT pMyDevice = NULL;
    UNICODE_STRING usSymboName = { 0 };
    UNICODE_STRING usDeviceName = { 0 };
         
    pMyDriver->MajorFunction[IRP_MJ_CREATE] = IrpFile;
    pMyDriver->MajorFunction[IRP_MJ_CLOSE]  = IrpFile;
    pMyDriver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = IrpIOCTL;
    pMyDriver->DriverUnload = Unload;
             
    RtlInitUnicodeString(&usDeviceName, L"\\Device\\MyDriver");
    IoCreateDevice(pMyDriver, 0, &usDeviceName, FILE_DEVICE_UNKNOWN, 0, FALSE, &pMyDevice);
    RtlInitUnicodeString(&usSymboName, L"\\DosDevices\\MyDriver");
    InitializeListHead(&stQueue);
    KeInitializeTimer(&stTime);
    KeInitializeDpc(&stTimeDPC, OnTimer, pMyDevice);
    IoCreateSymbolicLink(&usSymboName, &usDeviceName);
    pMyDevice->Flags &= ~DO_DEVICE_INITIALIZING;
    pMyDevice->Flags |= DO_BUFFERED_IO;
    return STATUS_SUCCESS;
}

app.c

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <winioctl.h>
#include <strsafe.h>
#include <setupapi.h>
 
#define IOCTL_QUEUE   CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PROCESS CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
int main(int argc, char* argv[])
{
    int i = 0;
    DWORD dwRet = 0;
    HANDLE hFile = NULL;
    OVERLAPPED ov[3] = { 0 };
 
    hFile = CreateFile("\\\\.\\MyDriver", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL, NULL);
    for (i = 0; i < 3; i++) {
        memset(&ov[i], 0, sizeof(ov[i]));
        ov[i].hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        printf("Queued Event\n");
        DeviceIoControl(hFile, IOCTL_QUEUE, NULL, 0, NULL, 0, &dwRet, &ov[i]);
    }
    printf("Processing All Events\n");
    DeviceIoControl(hFile, IOCTL_PROCESS, NULL, 0, NULL, 0, &dwRet, NULL);
    for (i = 0; i < 3; i++) {
        WaitForSingleObject(ov[i].hEvent, INFINITE);
        CloseHandle(ov[i].hEvent);
        printf("Complete\n");
    }
    CloseHandle(hFile);
    return 0;
}

完成