1）跳入到基础篇的内核编程第7章，驱动入口函数DriverEnter的返回值决定驱动程序是否加载成功，当打算反汇编阅读驱动内核程序时，可寻找该位置。
2）DRIVER_OBJECT下的派遣函数（分发函数）指针的个数为：IRP_MJ_MAXINUM_FUNCTION，保存在一个数组中，编写驱动程序，实质上就是自己编写处理I/O请求IRP包的派遣函数，可以使用for循环将所有的派遣函数注册到同一个派遣函数。分发函数类似MFC消息机制中的回调函数，它的名字也是程序员自定义的，但是参数确定。卸载函数通过地址在驱动对象的DriverUnload域，在驱动卸载中会自动调用该函数。由于DriverUnload函数没有返回值，所以不能决定是否真正被卸载，只能做一些善后处理。
3）驱动程序和系统其它组件之间的交互是通过给设备对象（DEVICE_OBJECT）发送或者接受发送给设备对象的请求（IRP包）来交互的（设备对象通过符号链接使其在运用层可见，如果不创建符号链接，则只在内核可见），一个驱动程序不创建设备，就不会受到任何IRP，分发函数也就失去了意义。但在一些只要HOOK等不需要交互的驱动，可以不创建设备。运用层使用符号链接可通过CreateFile像打开文件一样打开设备，只不过路径格式为“\\\\.\\设备符号链接”。
4）IoCreateDevice生成的设备有权限限制，使用IoCreateDeviceSecure（在wdmsec.lib中）可以对所有用户开放权限，函数原型为：
NTSTATUS IoCreateDeviceSecure(
IN PDRIVER_OBJECT DriverObject,
IN ULONG DeviceExtensionSize,
IN PUNICODE_STRING DeviceName OPTIONAL,
IN DEVICE_TYPE DeviceType,
IN ULONG DeviceCharacteristics,
IN BOOLEAN Exclusive,
IN PCUNICODE_STRING DefaultSDDLString,
IN LPCGUID DeviceClassGuid,
OUT PDEVICE_OBJECT *DeviceObject
);
这个函数增加了两个内容（注：亲测不通过，不知道还需要导入什么lib文件而作者没提到）：
a）DefaultSDDLString：描述权限的字符串，使用“D:P(A;;GA;;;WD)”即可对所有用户开放权限，如：UNICODE_STRING sddl = RTL_CONSTANT_STRING(L” D:P(A;;GA;;;WD)”)
b）DeviceClassGuid：随便填写GUID，不与其他设备冲突即可。如：const GUID DECLSPEC_SELECTANY MYGUID_CLASS_MYCDO = {0x26e0d1e0L,0x8189,0x12e0,{0x99,0x14,0x88,0x00,0x22,0x30,0x19,0x13}}
5）在\DosDevices\（注：由《驱动开发技术详解》可知，WDM驱动为\DosDevice\，而ddk驱动为\??\，我测试使用的是ddk，作者并未说明，而如下代码暂时未测试）下的简单符号链接并不是对所有用户可见，但是在DriverEnter中生成符号链接则对所有用户可见，因为入口函数总是在进程“System”中，但是注销后可能消失。解决办法：生成全局符号链接“\DosDevice\Global\符号链接”即可，在不支持符号链接用户相关性的系统上，使用如下代码：
UNICODE_STRING device_name;
UNICODE_STRING symbl_name;
, 0x10) )
{
//如果支持符号链接用户相关，用全局符号链接
RtlInitUnicodeString(&symbl_name,L” \\DosDevice\\Global\\符号链接”);
}
else
{
//如果不支持，则不用全局的
RtlInitUnicodeString(&symbl_name,L” \\DosDevice\\符号链接”);
}
IoCreateSymbolicLink(&symbl_name,&device_name);
6）IRP类型取决于主功能号，也就是DRIVER_OBJECT中分发函数指针数组中的索引（如IRP_MJ_CREATE等）。IRP主功能号在IRP的当前栈空间。打开设备IRP可简单返回成功，这需要3个步骤（返回失败也一样）：
a）设置pIrp->IoStatus.Information=0
b）设置pIrp->IoStatus.Status=STATUS_SUCCESS（如果要让处理失败，则返回错误代码）
c）调用IoCompleteRequest(pIrp,IO_NO_INCREMENT)这个函数指示完成IRP处理
完成以上3步以后可直接返回pIrp->IoStatus.Status。
7）运用层消息传入：可使用WriteFile，也可以使用DeviceIoControl（设备控制接口），后者是双向的。DeviceIoControl的IRP携带了控制码（必须预先宏定义）、输入缓冲区位置和长度，以及输出缓冲区和位置长度，使用示例（注：DDk驱动代码，实现的功能是在R3层MFC运用程序点击一个按钮，将发送一个字符串到R0内核程序，内核程序接收字符串并打印它）：
//最后修改13-10-15
#include "xde.h"
#include <ntddk.h>
#define INITCODE code_seg("INIT") /*指的代码运行后就从内存释放掉*/
#define PAGECODE code_seg("PAGE") /*表示内存不足时，可以被置换到硬盘*/
#define DEVNAME L"\\Device\\testDDk_Device"
#define SYMNAME L"\\??\\TestLinkName"
//IRP_MJ_DEVICE_CONTROL类型IRP用于R3运用程序写，内核读数据时的控制码宏定义
#define MY_DVC_IN_CODE (ULONG)CTL_CODE(\
FILE_DEVICE_UNKNOWN,/*设备类型*/\
0xa01,/*用户自定义功能号*/\
METHOD_BUFFERED,/*传输方式：带缓冲区*/\
FILE_WRITE_DATA/*调用者需求权限：文件写*/)
typedef unsigned long ULONG;
//函数声明
NTSTATUS CreateMyDevice (IN PDRIVER_OBJECT pDriverObject);//创建设备对象与符号链接
NTSTATUS ddk_DispatchRoutine_CONTROL(IN PDEVICE_OBJECT pDevobj,IN PIRP pIrp);//派遣函数
DRIVER_INITIALIZE DriverEntry;//入口，添加设备，启动HOOk
DRIVER_UNLOAD DriverUnload;//卸载，删除设备，停止HOOk
/////////////////////////////////////////////////////////////////
#pragma PAGECODE
//DriverEntry,入口函数。相当于main
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING sRegPath)
{
//创建设备对象与符号链接
CreateMyDevice (pDriverObject);
//派遣函数
pDriverObject->MajorFunction[IRP_MJ_CREATE]=ddk_DispatchRoutine_CONTROL;//IRP_MJ_CREATE相关IRP处理函数
pDriverObject->MajorFunction[IRP_MJ_CLOSE]=ddk_DispatchRoutine_CONTROL;//IRP_MJ_CREATE相关IRP处理函数
pDriverObject->MajorFunction[IRP_MJ_READ]=ddk_DispatchRoutine_CONTROL;//IRP_MJ_CREATE相关IRP处理函数
pDriverObject->MajorFunction[IRP_MJ_CLOSE]=ddk_DispatchRoutine_CONTROL;//IRP_MJ_CREATE相关IRP处理函数
pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]=ddk_DispatchRoutine_CONTROL; //IRP_MJ_CREATE相关IRP处理函数
pDriverObject->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}
///////////////////////////////////////////////////////////////////
#pragma PAGECODE
//提供一个Unload函数值是为了让这个程序能动态卸载，方便调试
VOID DriverUnload(PDRIVER_OBJECT pDriverObject)
{
PDEVICE_OBJECT pDev;//用来取得要删除设备对象
UNICODE_STRING symLinkName; //
//打印一句
KdPrint(("Our driver is unloading...\n"));
pDev=pDriverObject->DeviceObject;//从驱动对象取得设备对象，所有设备对象连成一条链，这里假定只有一个设备
IoDeleteDevice(pDev); //删除设备
RtlInitUnicodeString(&symLinkName,SYMNAME);
//删除符号链接
IoDeleteSymbolicLink(&symLinkName);
KdPrint(("驱动成功被卸载... ")); //sprintf,printf
//取得要删除设备对象
//删掉所有设备
}
//读取IRP_MJ_DEVICE_CONTROL类型IRP包中的数据信息：驱动读
NTSTATUS MyDeviceIoCtrlIn(PIRP pIrp)
{
PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(pIrp);
//得到输入缓存长度
ULONG in_len = irpsp->Parameters.DeviceIoControl.InputBufferLength;
//输入输出缓冲是公用内存的
PVOID buffer = pIrp->AssociatedIrp.SystemBuffer;
//输出缓冲区信息
KdPrint(("The Messege from R3 is : %s \n",buffer));
pIrp->IoStatus.Information = in_len;//设置IRP读取的字节数
pIrp->IoStatus.Status=STATUS_SUCCESS;//设置IRP处理状态
IoCompleteRequest(pIrp,IO_NO_INCREMENT);//指示完成此IRP的处理
return STATUS_SUCCESS; //返回成功，这样，发起I/O操作的Win32API将会返回TRUE，使用GetLastError和设置的IPR处理状态一致
}
//分类处理
NTSTATUS ddk_DispatchRoutine_CONTROL(IN PDEVICE_OBJECT pDevobj, IN PIRP pIrp)
{
//IoGetCurrentIrpStackLocation得到调用者堆栈的指针
PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(pIrp);
//判断IRP请求包的类型
switch(irpsp->MajorFunction)
{
case IRP_MJ_CREATE://处理打开请求(CreateFile)
KdPrint(("IRP_MJ_CREATE\n"));
break;
case IRP_MJ_CLOSE://处理关闭请求(CloseHandle)
KdPrint(("IRP_MJ_CLOSE\n"));
break;
case IRP_MJ_READ://处理读请求(ReadFile)
KdPrint(("IRP_MJ_READ\n"));
break;
case IRP_MJ_WRITE://处理写请求(WriteFile)
KdPrint(("IRP_MJ_WRITE\n"));
break;
case IRP_MJ_DEVICE_CONTROL://处理设备控制信息(DeviceIoControl)
{
//首先得到功能号
ULONG code = irpsp->Parameters.DeviceIoControl.IoControlCode;
KdPrint(("IRP_MJ_DEVICE_CONTROL\n"));
if ( code == MY_DVC_IN_CODE )//内核读取数据
{
KdPrint(("MY_DVC_IN_CODE\n"));
return MyDeviceIoCtrlIn(pIrp);
}
break;
}
default:
KdPrint(("其它处理\n"));
}
pIrp->IoStatus.Information=;//设置IRP操作的字节数为，这里无实际意义
pIrp->IoStatus.Status=STATUS_SUCCESS;//设置IRP处理状态
IoCompleteRequest(pIrp,IO_NO_INCREMENT);//指示完成此IRP的处理
return STATUS_SUCCESS; //返回成功，这样，发起I/O操作的Win32API将会返回TRUE，使用GetLastError和设置的IPR处理状态一致
}
#pragma INITCODE
NTSTATUS CreateMyDevice (IN PDRIVER_OBJECT pDriverObject)
{
NTSTATUS status;
PDEVICE_OBJECT pDevObj;/*用来返回创建设备结构体的指针*/
//设备对象(DEVICE_OBJECT)由驱动创建。一个驱动可以创建多个设备对象。
//通过驱动对象(DRIVER_OBJECT)，可以找到由该驱动创建的所有设备对象。
//一个驱动创建的所有设备对象链成一条链。该驱动的驱动对象可以找到这个链，
//一个设备对象也可以找到创建它的驱动的驱动对象。DEVICE_OBJECT是设备对象存在的形式
//创建设备名称
UNICODE_STRING devName;
UNICODE_STRING symLinkName; // 结构体，包含了宽字节字符缓冲区与其长度
RtlInitUnicodeString(&devName,DEVNAME);//对devName初始化字串为"\\Device\\testDDK_Device"
//这个宽字节的路径“\\Device\\ ”部分不能改变，后面是设备名称
//创建设备对象
status = IoCreateDevice ( pDriverObject, //驱动程序对象指针。在入库函数DriverEntry过程里接收
,//指定驱动程序为设备扩展对象定义的结构体大小
&devName,//设备名称，必须是完整的设备路径名，设置为NULL则是无名设备
FILE_DEVICE_UNKNOWN,//设备类型
, TRUE,//驱动程序的其它信息以及指定设备是否是独占的，TRUE则是
&pDevObj);//输出，用来保存PDEVICE_OBJECT结构体指针，这个指针指向设备对象自身
if (!NT_SUCCESS(status))
{
if (status==STATUS_INSUFFICIENT_RESOURCES)
{
KdPrint(("资源不足STATUS_INSUFFICIENT_RESOURCES"));
}
if (status==STATUS_OBJECT_NAME_EXISTS )
{
KdPrint(("指定对象名存在"));
}
if (status==STATUS_OBJECT_NAME_COLLISION)
{
KdPrint(("//对象名有冲突"));
}
KdPrint(("设备创建失败...++++++++"));
return status;
}
KdPrint(("设备创建成功...++++++++"));
// IoCreateDevice 会把新创建的这个设备对象，链入驱动的设备链中
pDevObj->Flags |= DO_BUFFERED_IO;
//创建符号链接
RtlInitUnicodeString(&symLinkName,SYMNAME);
status = IoCreateSymbolicLink( &symLinkName,// Unicode字符串指针，是一个用户态可见的名称
&devName );// Unicode字符串指针，是驱动程序创建的设备对象名称。
if (!NT_SUCCESS(status)) /*status等于*/
{
IoDeleteDevice( pDevObj );//删除驱动设备
return status;
}
return STATUS_SUCCESS;
}
在R3运用程序上，进行DeviceIoControl代码（写MFC程序，添加按钮点击事件）：
//在头文件添加
#include <winioctl.h>
#define SYMNAME "\\\\.\\TestLinkName"
//IRP_MJ_DEVICE_CONTROL类型IRP用于R3运用程序写，内核读数据时的控制码宏定义
#define MY_DVC_IN_CODE (ULONG)CTL_CODE(\
FILE_DEVICE_UNKNOWN,/*设备类型*/\
0xa01,/*用户自定义功能号*/\
METHOD_BUFFERED,/*传输方式：带缓冲区*/\
FILE_WRITE_DATA/*调用者需求权限：文件写*/)
//添加按钮点击事件
// TODO: 在此添加控件通知处理程序代码
DWORD length = ;//返回的长度
HANDLE device = CreateFile(SYMNAME,
GENERIC_READ|GENERIC_WRITE,,,
OPEN_EXISTING,
FILE_ATTRIBUTE_SYSTEM,);
if ( device == INVALID_HANDLE_VALUE )
{
//打开失败
AfxMessageBox(_T("打开符号链接失败"));
return;
}
CString message("Hello R0");
LPVOID in_buffer = message.GetBuffer();
int in_buffer_len = message.GetLength();
BOOL ret = DeviceIoControl(device,
MY_DVC_IN_CODE, //功能号
in_buffer, //输入缓冲，要传递的信息，预先填好
in_buffer_len, //输入缓冲长度
NULL, //没有输出缓冲
, //输出缓冲为长度
&length, //返回的长度
NULL);
if (!ret)
{
// DeviceIoControl失败
AfxMessageBox(_T("DeviceIoControl失败"));
}
if ( length != in_buffer_len)
{
AfxMessageBox(_T("读取字节数不一致"));
}
输出效果：
8）驱动层消息传出：运用程序需要开启一个线程调用DeviceIoControl（或者ReadFile）读取数据，而驱动在没有消息的时候阻塞这个IRP，等待有消息时返回（使用事件也行，但还要传递事件句柄，较繁琐）。驱动内部制作一个链表，当有消息的要通知运用程序时，把消息放入链表，并设置同步事件，在DeviceIoControl的处理中等待事件。这里测试一下，避免麻烦，传送一个ULONG类型，传输10次，R3运用程序开线程接收，不停的弹窗，这里不考虑数据覆盖问题。
//内核程序
#include "xde.h"
#include <ntddk.h>
#define INITCODE code_seg("INIT") /*指的代码运行后就从内存释放掉*/
#define PAGECODE code_seg("PAGE") /*表示内存不足时，可以被置换到硬盘*/
#define DELAY_ONE_MICROSECOND (-10)
#define DELAY_ONE_MILLISECOND (DELAY_ONE_MICROSECOND*1000)
#define DEVNAME L"\\Device\\testDDk_Device"
#define SYMNAME L"\\??\\TestLinkName"
//IRP_MJ_DEVICE_CONTROL类型IRP用于R3运用程序读，内核写数据时的控制码宏定义
#define MY_DVC_OUT_CODE (ULONG)CTL_CODE(\
FILE_DEVICE_UNKNOWN,/*设备类型*/\
0xa02,/*用户自定义功能号*/\
METHOD_BUFFERED,/*传输方式：带缓冲区*/\
FILE_READ_DATA/*调用者需求权限：文件读*/)
typedef unsigned long ULONG;
typedef ULONG* PULONG;
//要发送的数据
tatic ULONG data;
//全局事件变量
static KEVENT g_my_notify_event;
//函数声明
NTSTATUS CreateMyDevice (IN PDRIVER_OBJECT pDriverObject);//创建设备对象与符号链接
NTSTATUS ddk_DispatchRoutine_CONTROL(IN PDEVICE_OBJECT pDevobj,IN PIRP pIrp);//派遣函数
void MySleep(LONG msec);//延时函数
void MyThreadProc(PVOID context);//测试线程
DRIVER_INITIALIZE DriverEntry;//入口，添加设备，启动HOOk
DRIVER_UNLOAD DriverUnload;//卸载，删除设备，停止HOOk
/////////////////////////////////////////////////////////////////
#pragma PAGECODE
//DriverEntry,入口函数。相当于main
NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING sRegPath)
{
HANDLE hThread = NULL;
NTSTATUS status;
//对ZwCreateSection进行HOOK
RtlInitUnicodeString(&apiFuncName,L"ZwCreateSection");
if (InlineHookIofCallDriverXp(&apiFuncName,(ULONG)MyIofCallDriver,TRUE) == FALSE)
{
KdPrint(("Inline Hook failed!\n"));
}
//创建设备对象与符号链接
CreateMyDevice (pDriverObject);
//派遣函数
pDriverObject->MajorFunction[IRP_MJ_CREATE]=ddk_DispatchRoutine_CONTROL;//IRP_MJ_CREATE相关IRP处理函数
pDriverObject->MajorFunction[IRP_MJ_CLOSE]=ddk_DispatchRoutine_CONTROL;//IRP_MJ_CREATE相关IRP处理函数
pDriverObject->MajorFunction[IRP_MJ_READ]=ddk_DispatchRoutine_CONTROL;//IRP_MJ_CREATE相关IRP处理函数
pDriverObject->MajorFunction[IRP_MJ_CLOSE]=ddk_DispatchRoutine_CONTROL;//IRP_MJ_CREATE相关IRP处理函数
pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]=ddk_DispatchRoutine_CONTROL; //IRP_MJ_CREATE相关IRP处理函数
//创建线程：
status = PsCreateSystemThread(
&hThread,//新线程句柄
0L,NULL,NULL,NULL,
MyThreadProc,//函数地址
NULL//传递参数
);
if ( !NT_SUCCESS(status) )
{
KdPrint(("CreateSystemThread failed!"));
}
ZwClose(hThread);
pDriverObject->DriverUnload = DriverUnload;
return STATUS_SUCCESS;
}
void MyThreadProc(PVOID context)
{
//测试
KeInitializeEvent(&g_my_notify_event,
SynchronizationEvent,//自动复位
FALSE//初始为无信号状态
);
; data <= + ; data ++)
{
//Sleep(3000)
MySleep();
//设置有信号
KeSetEvent(&g_my_notify_event,
IO_NO_INCREMENT,//预备给被唤醒线程临时提升优先级的增量
FALSE//之后是否跟KeWaitForXXX等待（其它或者自身）事件
);
KdPrint(("The data is : %u \n",data));
}
}
void MySleep(LONG msec)
{
LARGE_INTEGER my_interval;
my_interval.QuadPart = DELAY_ONE_MILLISECOND;
my_interval.QuadPart *= msec;
KeDelayExecutionThread(KernelMode,,&my_interval);
}
//提供一个Unload函数值是为了让这个程序能动态卸载，方便调试
VOID DriverUnload(PDRIVER_OBJECT pDriverObject)
{
PDEVICE_OBJECT pDev;//用来取得要删除设备对象
UNICODE_STRING symLinkName; //
//打印一句
KdPrint(("Our driver is unloading...\n"));
//停止HOOk
if(InlineHookIofCallDriverXp(&apiFuncName,(ULONG)MyIofCallDriver,FALSE) == FALSE)
{
KdPrint(("UnHook failed!\n"));
}
KdPrint(("UnHook succeed!\n"));
pDev=pDriverObject->DeviceObject;//从驱动对象取得设备对象，所有设备对象连成一条链，这里假定只有一个设备
IoDeleteDevice(pDev); //删除设备
RtlInitUnicodeString(&symLinkName,SYMNAME);
//删除符号链接
IoDeleteSymbolicLink(&symLinkName);
KdPrint(("驱动成功被卸载... ")); //sprintf,printf
//取得要删除设备对象
//删掉所有设备
}
//读取IRP_MJ_DEVICE_CONTROL类型IRP包中的数据信息：驱动写
NTSTATUS MyDeviceIoCtrlOut(PIRP pIrp)
{
PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(pIrp);
//获得输出缓冲区
PVOID buffer = pIrp->AssociatedIrp.SystemBuffer;
//获取输出缓冲区长度
ULONG out_len = irpsp->Parameters.DeviceIoControl.OutputBufferLength;
//等待有事件信号
KeWaitForSingleObject(&g_my_notify_event,
Executive,//等待原因，驱动程序设置为Executive
KernelMode,//内核模式
FALSE,//不允许警告
NULL//等待超时时间：无限等待
);
//有请求了
if (out_len < sizeof(ULONG) )//缓冲长度不够
{
pIrp->IoStatus.Information = sizeof(ULONG);//写需要的长度
pIrp->IoStatus.Status = STATUS_INVALID_BUFFER_SIZE;
IoCompleteRequest(pIrp,IO_NO_INCREMENT);
return pIrp->IoStatus.Status;
}
//长度足够，填写输出缓冲区
*((PULONG)buffer) = data;
//返回成功
pIrp->IoStatus.Information = sizeof(ULONG);//写入的长度
pIrp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(pIrp,IO_NO_INCREMENT);//指示完成此IRP的处理
return STATUS_SUCCESS; //返回成功，这样，发起I/O操作的Win32API将会返回TRUE，使用GetLastError和设置的IPR处理状态一致
}
//分类处理
NTSTATUS ddk_DispatchRoutine_CONTROL(IN PDEVICE_OBJECT pDevobj, IN PIRP pIrp)
{
//IoGetCurrentIrpStackLocation得到调用者堆栈的指针
PIO_STACK_LOCATION irpsp = IoGetCurrentIrpStackLocation(pIrp);
//判断IRP请求包的类型
switch(irpsp->MajorFunction)
{
case IRP_MJ_CREATE://处理打开请求(CreateFile)
KdPrint(("IRP_MJ_CREATE\n"));
break;
case IRP_MJ_CLOSE://处理关闭请求(CloseHandle)
KdPrint(("IRP_MJ_CLOSE\n"));
break;
case IRP_MJ_READ://处理读请求(ReadFile)
KdPrint(("IRP_MJ_READ\n"));
break;
case IRP_MJ_WRITE://处理写请求(WriteFile)
KdPrint(("IRP_MJ_WRITE\n"));
break;
case IRP_MJ_DEVICE_CONTROL://处理设备控制信息(DeviceIoControl)
{
//首先得到功能号
ULONG code = irpsp->Parameters.DeviceIoControl.IoControlCode;
KdPrint(("IRP_MJ_DEVICE_CONTROL\n"));
if ( code == MY_DVC_OUT_CODE)//内核传出数据
{
KdPrint(("MY_DVC_OUT_CODE\n"));
return MyDeviceIoCtrlOut(pIrp);
}
break;
}
default:
KdPrint(("其它处理\n"));
}
//判断是输入还是输出操作
pIrp->IoStatus.Information=;//设置IRP操作的字节数为，这里无实际意义
pIrp->IoStatus.Status=STATUS_SUCCESS;//设置IRP处理状态
IoCompleteRequest(pIrp,IO_NO_INCREMENT);//指示完成此IRP的处理
return STATUS_SUCCESS; //返回成功，这样，发起I/O操作的Win32API将会返回TRUE，使用GetLastError和设置的IPR处理状态一致
}
/////////////////////////////////////////////////////////////////
#pragma INITCODE
NTSTATUS CreateMyDevice (IN PDRIVER_OBJECT pDriverObject)
{
NTSTATUS status;
PDEVICE_OBJECT pDevObj;
//创建设备名称
UNICODE_STRING devName;
UNICODE_STRING symLinkName;
RtlInitUnicodeString(&devName,DEVNAME);
//创建设备对象
status = IoCreateDevice/*Secure*/( pDriverObject, //驱动程序对象指针。在入库函数DriverEntry过程里接收
,//指定驱动程序为设备扩展对象定义的结构体大小
&devName,//设备名称，必须是完整的设备路径名，设置为NULL则是无名设备
FILE_DEVICE_UNKNOWN,//设备类型
, TRUE,//驱动程序的其它信息以及指定设备是否是独占的，TRUE则是
//&sddl,(LPCGUID)&MYGUID_CLASS_MYCDO,//sddl,guid
&pDevObj);//输出，用来保存PDEVICE_OBJECT结构体指针，这个指针指向设备对象自身
if (!NT_SUCCESS(status))
{
if (status==STATUS_INSUFFICIENT_RESOURCES)
{
KdPrint(("资源不足STATUS_INSUFFICIENT_RESOURCES"));
}
if (status==STATUS_OBJECT_NAME_EXISTS )
{
KdPrint(("指定对象名存在"));
}
if (status==STATUS_OBJECT_NAME_COLLISION)
{
KdPrint(("//对象名有冲突"));
}
KdPrint(("设备创建失败...++++++++"));
return status;
}
KdPrint(("设备创建成功...++++++++"));
// IoCreateDevice 会把新创建的这个设备对象，链入驱动的设备链中
pDevObj->Flags |= DO_BUFFERED_IO;
//创建符号链接
RtlInitUnicodeString(&symLinkName,SYMNAME);
status = IoCreateSymbolicLink( &symLinkName,// Unicode字符串指针，是一个用户态可见的名称
&devName );// Unicode字符串指针，是驱动程序创建的设备对象名称。
if (!NT_SUCCESS(status)) /*status等于*/
{
IoDeleteDevice( pDevObj );//删除驱动设备
return status;
}
return STATUS_SUCCESS;
}
R3接收程序：
#include <winioctl.h>
#define SYMNAME "\\\\.\\TestLinkName"
//IRP_MJ_DEVICE_CONTROL类型IRP用于R3运用程序读，内核写数据时的控制码宏定义
#define MY_DVC_OUT_CODE (ULONG)CTL_CODE(\
FILE_DEVICE_UNKNOWN,/*设备类型*/\
0xa02,/*用户自定义功能号*/\
METHOD_BUFFERED,/*传输方式：带缓冲区*/\
FILE_READ_DATA/*调用者需求权限：文件读*/)
DWORD MyThreadProc(void);
//按钮事件
void CMFCTestDlg::OnBnClickedButton1()
{
CreateThread(NULL,,(LPTHREAD_START_ROUTINE)MyThreadProc,NULL,NULL,NULL);
}
DWORD MyThreadProc(void)
{
// TODO: 在此添加控件通知处理程序代码
ULONG data = ;//返回的数据
DWORD length = ;//返回的长度
HANDLE device = CreateFile(SYMNAME,
GENERIC_READ|GENERIC_WRITE,,,
OPEN_EXISTING,
FILE_ATTRIBUTE_SYSTEM,);
if ( device == INVALID_HANDLE_VALUE )
{
//打开失败
AfxMessageBox(_T("打开符号链接失败"));
return FALSE;
}
;
)
{
BOOL ret = DeviceIoControl(device,
MY_DVC_OUT_CODE, //功能号
NULL, //没有输入缓冲，要传递的信息，预先填好
NULL, //输入缓冲长度为
&data, //输出缓冲
sizeof(ULONG), //输出缓冲长度
&length, //返回的长度
NULL);
if (!ret)
{
// DeviceIoControl失败
AfxMessageBox(_T("DeviceIoControl失败"));
}
CString a;
a.Format("%u",data);
AfxMessageBox(a);
}
CloseHandle(device);
return TRUE;
}
效果图：
