Windows驱动开发：应用DeviceIoContro模板精讲

ytn2001

通过封装一套标准通用模板来实现驱动通信中的常用传递方式，这其中包括了如何传递字符串，传递整数，传递数组，传递结构体等方法。

可以说如果你能掌握本章模板精讲的内容基本上市面上的功能都可以使用本方法进行通信。

首先定义驱动功能号和名字，提供接口给应用程序调用。

1. #define IOCTL_IO_Msg            CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)
   
2. #define IOCTL_IO_TEST           CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
   
3. #define IOCTL_IO_Array          CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED, FILE_ANY_ACCESS)
   
4. #define IOCTL_IO_STRUCT         CTL_CODE(FILE_DEVICE_UNKNOWN, 0x803, METHOD_BUFFERED, FILE_ANY_ACCESS)
   
5. #define IOCTL_IO_String         CTL_CODE(FILE_DEVICE_UNKNOWN, 0x804, METHOD_BUFFERED, FILE_ANY_ACCESS)

复制代码

IOCTL_IO_TEST 传递整数： 派遣例程用于传递整数类型，首先客户端通过DriveControl.IoControl将数据通过变量input传入到内核中，并等待返回，如果返回了结果则outpot里存储的就是返回结果，ref_len则是返回长度。

看看客户端如何接收这个数据的传递。

1. // 传入x参数,返回到y中,返回长度为z
   
2. DWORD input = 100, output = 0, ref_len = 0;
   
3. DriveControl.IoControl(IOCTL_IO_TEST, &input, sizeof(input), &output, sizeof(output), &ref_len);
   
4. 
   
5. std::cout << "传入参数: " << input << std::endl;
   
6. std::cout << "输出参数: " << output << std::endl;
   
7. std::cout << "参数长度: " << ref_len << std::endl;

复制代码

对于驱动中我们不需要做任何操作只需要通过memcpy(&dw, pIoBuffer, sizeof(DWORD))得到缓冲区内的数据，对该数据dw++递增，最后通过memcpy(pIoBuffer, &dw, sizeof(DWORD))再将数据写回到应用层。

1. case IOCTL_IO_TEST:
   
2. {
   
3.   DWORD dw = 0;
   
4. 
   
5.   // 得到输入参数
   
6.   memcpy(&dw, pIoBuffer, sizeof(DWORD));
   
7. 
   
8.   // 对输入参数进行处理
   
9.   dw++;
   
10. 
    
11.   // 设置输出参数
    
12.   memcpy(pIoBuffer, &dw, sizeof(DWORD));
    
13. 
    
14.   // 返回通信状态
    
15.   status = STATUS_SUCCESS;
    
16.   break;
    
17. }

复制代码

IOCTL_IO_Array 传递数组： 派遣例程用于传递数组类型，首先定义数组MyArray将数组首地址以及数组长度传递到内核中，内核收到首地址以及长度后通过uInSize / sizeof(int)得到每一个元素的长度，最后循环输出元素即可。

1. // --------------------------------------------------------------------------
   
2. // 应用层
   
3. // --------------------------------------------------------------------------
   
4. // 传入数组
   
5. int MyArray[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
   
6. int array_count = 10 * sizeof(int);
   
7. 
   
8. DriveControl.IoControl(IOCTL_IO_Array, &MyArray, array_count, 0, 0, 0);
   
9. 
   
10. // --------------------------------------------------------------------------
    
11. // 内核层
    
12. // --------------------------------------------------------------------------
    
13. // 输出一个数组
    
14. case IOCTL_IO_Array:
    
15. {
    
16.         int *ArrayPtr = (int *)pIoBuffer;
    
17.         int count = uInSize / sizeof(int);
    
18. 
    
19.         for (int x = 0; x < count; x++)
    
20.         {
    
21.                 DbgPrint("计数器: %d \n", ArrayPtr[x]);
    
22.         }
    
23. 
    
24.         status = STATUS_SUCCESS;
    
25.         break;
    
26. }

复制代码

IOCTL_IO_STRUCT 传递结构： 结构体的传输与数组类似，仅仅只是在接收到数据后对其进行一定的转换即可，应用层只需要DriveControl.IoControl发送send_ptr指针并等待回传recv_ptr即可，最后将得到的结果直接输出，而内核层收到数据后仅仅也只需要(MyData *)pIoBuffer将数据转为一个指针即可操作这片区域，当操作完成时以同样的方式memcpy(pIoBuffer, &send_data, sizeof(MyData))`返回一个结构体给应用层。

1. // --------------------------------------------------------------------------
   
2. // 应用层
   
3. // --------------------------------------------------------------------------
   
4. // 传入一个结构体,返回结构体
   
5. MyData send_ptr, recv_ptr;
   
6. DWORD dwSize = 0;
   
7. 
   
8. memset(send_ptr.szUname, 0, 1024);
   
9. memset(recv_ptr.szUname, 0, 1024);
   
10. 
    
11. send_ptr.uuid = 1001;
    
12. strcpy(send_ptr.szUname, "lyshark");
    
13. 
    
14. // 派遣命令
    
15. DriveControl.IoControl(IOCTL_IO_STRUCT, &send_ptr, sizeof(send_ptr), &recv_ptr, sizeof(recv_ptr), &dwSize);
    
16. // DeviceIoControl(hDevice, IOCTL_IO_STRUCT, &send_ptr, sizeof(send_ptr), (LPVOID)&recv_ptr, sizeof(recv_ptr), &dwSize, 0);
    
17. 
    
18. std::cout << "内核返回数据: " << recv_ptr.uuid << std::endl;
    
19. std::cout << "内核返回数据: " << recv_ptr.szUname << std::endl;
    
20. std::cout << "内核返回长度: " << dwSize << std::endl;
    
21. 
    
22. // --------------------------------------------------------------------------
    
23. // 内核层
    
24. // --------------------------------------------------------------------------
    
25. // 测试传递结构体
    
26. case IOCTL_IO_STRUCT:
    
27. {
    
28.         MyData recv_data, send_data;
    
29. 
    
30.         // 获取到应用层传入的数据
    
31.         /*
    
32.         MyData *ptr = (MyData *)pIoBuffer;
    
33.         DbgPrint("获取序列号: %d \n", ptr->uid);
    
34.         DbgPrint("获取名字: %s \n", ptr->szBuf);
    
35.         */
    
36. 
    
37.         // 获取数据
    
38.         memcpy(&recv_data, pIoBuffer, sizeof(MyData));
    
39.         DbgPrint("[驱动读入]: UID: %d --> Name: %s \n", recv_data.uuid, recv_data.szUname);
    
40. 
    
41.         // 发送数据
    
42.         memset(send_data.szUname, 0, 1024);
    
43.         send_data.uuid = 1002;
    
44.         strcpy(send_data.szUname, "lyshark");
    
45.         memcpy(pIoBuffer, &send_data, sizeof(MyData));
    
46. 
    
47.         status = STATUS_SUCCESS;
    
48.         break;
    
49. }

复制代码

如上就是内核层与应用层的部分代码功能分析，至于传递字符串也很简单大家自己学习下即可掌握，接下来我将完整代码分享出来，大家可以自行测试效果。

驱动程序WinDDK.sys完整代码；

1. // 署名权
   
2. // right to sign one's name on a piece of work
   
3. // PowerBy: LyShark
   
4. // Email: me@lyshark.com
   
5. 
   
6. #define _CRT_SECURE_NO_WARNINGS
   
7. #include <ntifs.h>
   
8. #include <windef.h>
   
9. 
   
10. // 定义符号链接，一般来说修改为驱动的名字即可
    
11. #define DEVICE_NAME        L"\\Device\\WinDDK"
    
12. #define LINK_NAME          L"\\DosDevices\\WinDDK"
    
13. #define LINK_GLOBAL_NAME   L"\\DosDevices\\Global\\WinDDK"
    
14. 
    
15. // 定义驱动功能号和名字，提供接口给应用程序调用
    
16. #define IOCTL_IO_Msg            CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
17. #define IOCTL_IO_TEST           CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
18. #define IOCTL_IO_Array          CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
19. #define IOCTL_IO_STRUCT         CTL_CODE(FILE_DEVICE_UNKNOWN, 0x803, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
20. #define IOCTL_IO_String         CTL_CODE(FILE_DEVICE_UNKNOWN, 0x804, METHOD_BUFFERED, FILE_ANY_ACCESS)
    
21. 
    
22. // 保存一段非分页内存,用于给全局变量使用
    
23. #define FILE_DEVICE_EXTENSION 4096
    
24. 
    
25. // 定义传递结构体
    
26. typedef struct
    
27. {
    
28.         int uuid;
    
29.         char szUname[1024];
    
30. }MyData;
    
31. 
    
32. // 驱动绑定默认派遣函数
    
33. NTSTATUS DefaultDispatch(PDEVICE_OBJECT _pDeviceObject, PIRP _pIrp)
    
34. {
    
35.         _pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
    
36.         _pIrp->IoStatus.Information = 0;
    
37.         IoCompleteRequest(_pIrp, IO_NO_INCREMENT);
    
38.         return _pIrp->IoStatus.Status;
    
39. }
    
40. 
    
41. // 驱动卸载的处理例程
    
42. VOID DriverUnload(PDRIVER_OBJECT pDriverObj)
    
43. {
    
44.         if (pDriverObj->DeviceObject)
    
45.         {
    
46.                 UNICODE_STRING strLink;
    
47. 
    
48.                 // 删除符号连接和设备
    
49.                 RtlInitUnicodeString(&strLink, LINK_NAME);
    
50.                 IoDeleteSymbolicLink(&strLink);
    
51.                 IoDeleteDevice(pDriverObj->DeviceObject);
    
52.                 DbgPrint("[kernel] # 驱动已卸载 \n");
    
53.         }
    
54. }
    
55. 
    
56. // IRP_MJ_CREATE 对应的处理例程，一般不用管它
    
57. NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    
58. {
    
59.         DbgPrint("[kernel] # 驱动处理例程载入 \n");
    
60.         pIrp->IoStatus.Status = STATUS_SUCCESS;
    
61.         pIrp->IoStatus.Information = 0;
    
62.         IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    
63.         return STATUS_SUCCESS;
    
64. }
    
65. 
    
66. // IRP_MJ_CLOSE 对应的处理例程，一般不用管它
    
67. NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    
68. {
    
69.         DbgPrint("[kernel] # 关闭派遣 \n");
    
70.         pIrp->IoStatus.Status = STATUS_SUCCESS;
    
71.         pIrp->IoStatus.Information = 0;
    
72.         IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    
73.         return STATUS_SUCCESS;
    
74. }
    
75. 
    
76. // IRP_MJ_DEVICE_CONTROL 对应的处理例程，驱动最重要的函数
    
77. NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
    
78. {
    
79.         NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
    
80.         PIO_STACK_LOCATION pIrpStack;
    
81.         ULONG uIoControlCode;
    
82.         PVOID pIoBuffer;
    
83.         ULONG uInSize;
    
84.         ULONG uOutSize;
    
85. 
    
86.         // 获得IRP里的关键数据
    
87.         pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
    
88. 
    
89.         // 获取控制码
    
90.         uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
    
91. 
    
92.         // 输入和输出的缓冲区（DeviceIoControl的InBuffer和OutBuffer都是它）
    
93.         pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;
    
94. 
    
95.         // EXE发送传入数据的BUFFER长度（DeviceIoControl的nInBufferSize）
    
96.         uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
    
97. 
    
98.         // EXE接收传出数据的BUFFER长度（DeviceIoControl的nOutBufferSize）
    
99.         uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
    
100. 
     
101.         // 对不同控制信号的处理流程
     
102.         switch (uIoControlCode)
     
103.         {
     
104.                 // 输出一段话
     
105.         case IOCTL_IO_Msg:
     
106.         {
     
107.                 DbgPrint("[Kernel] --> hello lyshark \n");
     
108.                 status = STATUS_SUCCESS;
     
109.                 break;
     
110.         }
     
111. 
     
112.         // 测试单一参数传递
     
113.         case IOCTL_IO_TEST:
     
114.         {
     
115.                 DWORD dw = 0;
     
116. 
     
117.                 // 得到输入参数
     
118.                 memcpy(&dw, pIoBuffer, sizeof(DWORD));
     
119. 
     
120.                 // 对输入参数进行处理
     
121.                 dw++;
     
122. 
     
123.                 // 设置输出参数
     
124.                 memcpy(pIoBuffer, &dw, sizeof(DWORD));
     
125. 
     
126.                 // 返回通信状态
     
127.                 status = STATUS_SUCCESS;
     
128.                 break;
     
129.         }
     
130. 
     
131.         // 输出一个数组
     
132.         case IOCTL_IO_Array:
     
133.         {
     
134.                 int *ArrayPtr = (int *)pIoBuffer;
     
135.                 int count = uInSize / sizeof(int);
     
136. 
     
137.                 for (int x = 0; x < count; x++)
     
138.                 {
     
139.                         DbgPrint("计数器: %d \n", ArrayPtr[x]);
     
140.                 }
     
141. 
     
142.                 status = STATUS_SUCCESS;
     
143.                 break;
     
144.         }
     
145. 
     
146.         // 测试传递结构体
     
147.         case IOCTL_IO_STRUCT:
     
148.         {
     
149.                 MyData recv_data, send_data;
     
150. 
     
151.                 // 获取到应用层传入的数据
     
152.                 /*
     
153.                 MyData *ptr = (MyData *)pIoBuffer;
     
154.                 DbgPrint("获取序列号: %d \n", ptr->uid);
     
155.                 DbgPrint("获取名字: %s \n", ptr->szBuf);
     
156.                 */
     
157. 
     
158.                 // 获取数据
     
159.                 memcpy(&recv_data, pIoBuffer, sizeof(MyData));
     
160.                 DbgPrint("[驱动读入]: UID: %d --> Name: %s \n", recv_data.uuid, recv_data.szUname);
     
161. 
     
162.                 // 发送数据
     
163.                 memset(send_data.szUname, 0, 1024);
     
164.                 send_data.uuid = 1002;
     
165.                 strcpy(send_data.szUname, "lyshark");
     
166.                 memcpy(pIoBuffer, &send_data, sizeof(MyData));
     
167. 
     
168.                 status = STATUS_SUCCESS;
     
169.                 break;
     
170.         }
     
171.         // 测试传递字符串
     
172.         case IOCTL_IO_String:
     
173.         {
     
174.                 char szString[256] = { 0 };
     
175.                 char szSendPtr[256] = { 0 };
     
176. 
     
177.                 // 接收字符串
     
178.                 memcpy(szString, pIoBuffer, sizeof(szString));
     
179.                 DbgPrint("[接收字符串]: %s \n", szString);
     
180. 
     
181.                 // 发送字符串
     
182.                 strcpy(szSendPtr, "hi, R3");
     
183.                 memcpy(pIoBuffer, &szSendPtr, sizeof(szSendPtr));
     
184. 
     
185.                 status = STATUS_SUCCESS;
     
186.                 break;
     
187.         }
     
188.         }
     
189. 
     
190.         // 设定DeviceIoControl的*lpBytesReturned的值（如果通信失败则返回0长度）
     
191.         if (status == STATUS_SUCCESS)
     
192.         {
     
193.                 pIrp->IoStatus.Information = uOutSize;
     
194.         }
     
195.         else
     
196.         {
     
197.                 pIrp->IoStatus.Information = 0;
     
198.         }
     
199. 
     
200.         // 设定DeviceIoControl的返回值是成功还是失败
     
201.         pIrp->IoStatus.Status = status;
     
202.         IoCompleteRequest(pIrp, IO_NO_INCREMENT);
     
203.         return status;
     
204. }
     
205. 
     
206. // 驱动的初始化工作
     
207. NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString)
     
208. {
     
209.         NTSTATUS status = STATUS_SUCCESS;
     
210.         UNICODE_STRING ustrLinkName;
     
211.         UNICODE_STRING ustrDevName;
     
212.         PDEVICE_OBJECT pDevObj;
     
213. 
     
214.         // 初始化其他派遣
     
215.         for (ULONG i = 0; i < IRP_MJ_MAXIMUM_FUNCTION; i++)
     
216.         {
     
217.                 // DbgPrint("初始化派遣: %d \n", i);
     
218.                 pDriverObj->MajorFunction[i] = DefaultDispatch;
     
219.         }
     
220. 
     
221.         // 设置分发函数和卸载例程
     
222.         pDriverObj->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
     
223.         pDriverObj->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
     
224.         pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;
     
225.         pDriverObj->DriverUnload = DriverUnload;
     
226. 
     
227.         // 创建一个设备
     
228.         RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);
     
229. 
     
230.         // FILE_DEVICE_EXTENSION 创建设备时，指定设备扩展内存的大小，传一个值进去，就会给设备分配一块非页面内存。
     
231.         status = IoCreateDevice(pDriverObj, sizeof(FILE_DEVICE_EXTENSION), &ustrDevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &pDevObj);
     
232.         if (!NT_SUCCESS(status))
     
233.         {
     
234.                 return status;
     
235.         }
     
236. 
     
237.         // 判断支持的WDM版本，其实这个已经不需要了，纯属WIN9X和WINNT并存时代的残留物
     
238.         if (IoIsWdmVersionAvailable(1, 0x10))
     
239.         {
     
240.                 RtlInitUnicodeString(&ustrLinkName, LINK_GLOBAL_NAME);
     
241.         }
     
242.         else
     
243.         {
     
244.                 RtlInitUnicodeString(&ustrLinkName, LINK_NAME);
     
245.         }
     
246. 
     
247.         // 创建符号连接
     
248.         status = IoCreateSymbolicLink(&ustrLinkName, &ustrDevName);
     
249.         if (!NT_SUCCESS(status))
     
250.         {
     
251.                 DbgPrint("创建符号链接失败 \n");
     
252.                 IoDeleteDevice(pDevObj);
     
253.                 return status;
     
254.         }
     
255.         DbgPrint("[ Hello LyShark.com ] # 驱动初始化完毕 \n");
     
256. 
     
257.         // 返回加载驱动的状态（如果返回失败，驱动讲被清除出内核空间）
     
258.         return STATUS_SUCCESS;
     
259. }

复制代码

应用层客户端程序lyshark.exe完整代码；

1. // 署名权
   
2. // right to sign one's name on a piece of work
   
3. // PowerBy: LyShark
   
4. // Email: me@lyshark.com
   
5. 
   
6. #include <iostream>
   
7. #include <Windows.h>
   
8. #include <vector>
   
9. 
   
10. #pragma comment(lib,"user32.lib")
    
11. #pragma comment(lib,"advapi32.lib")
    
12. 
    
13. // 定义驱动功能号和名字，提供接口给应用程序调用
    
14. #define IOCTL_IO_Msg            0x800
    
15. #define IOCTL_IO_TEST           0x801
    
16. #define IOCTL_IO_Array          0x802
    
17. #define IOCTL_IO_STRUCT         0x803
    
18. #define IOCTL_IO_String         0x804
    
19. 
    
20. class cDrvCtrl
    
21. {
    
22. public:
    
23.         cDrvCtrl()
    
24.         {
    
25.                 m_pSysPath = NULL;
    
26.                 m_pServiceName = NULL;
    
27.                 m_pDisplayName = NULL;
    
28.                 m_hSCManager = NULL;
    
29.                 m_hService = NULL;
    
30.                 m_hDriver = INVALID_HANDLE_VALUE;
    
31.         }
    
32.         ~cDrvCtrl()
    
33.         {
    
34.                 CloseServiceHandle(m_hService);
    
35.                 CloseServiceHandle(m_hSCManager);
    
36.                 CloseHandle(m_hDriver);
    
37.         }
    
38. 
    
39.         // 安装驱动
    
40.         BOOL Install(PCHAR pSysPath, PCHAR pServiceName, PCHAR pDisplayName)
    
41.         {
    
42.                 m_pSysPath = pSysPath;
    
43.                 m_pServiceName = pServiceName;
    
44.                 m_pDisplayName = pDisplayName;
    
45.                 m_hSCManager = OpenSCManagerA(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    
46.                 if (NULL == m_hSCManager)
    
47.                 {
    
48.                         m_dwLastError = GetLastError();
    
49.                         return FALSE;
    
50.                 }
    
51.                 m_hService = CreateServiceA(m_hSCManager, m_pServiceName, m_pDisplayName,
    
52.                         SERVICE_ALL_ACCESS, SERVICE_KERNEL_DRIVER, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
    
53.                         m_pSysPath, NULL, NULL, NULL, NULL, NULL);
    
54.                 if (NULL == m_hService)
    
55.                 {
    
56.                         m_dwLastError = GetLastError();
    
57.                         if (ERROR_SERVICE_EXISTS == m_dwLastError)
    
58.                         {
    
59.                                 m_hService = OpenServiceA(m_hSCManager, m_pServiceName, SERVICE_ALL_ACCESS);
    
60.                                 if (NULL == m_hService)
    
61.                                 {
    
62.                                         CloseServiceHandle(m_hSCManager);
    
63.                                         return FALSE;
    
64.                                 }
    
65.                         }
    
66.                         else
    
67.                         {
    
68.                                 CloseServiceHandle(m_hSCManager);
    
69.                                 return FALSE;
    
70.                         }
    
71.                 }
    
72.                 return TRUE;
    
73.         }
    
74. 
    
75.         // 启动驱动
    
76.         BOOL Start()
    
77.         {
    
78.                 if (!StartServiceA(m_hService, NULL, NULL))
    
79.                 {
    
80.                         m_dwLastError = GetLastError();
    
81.                         return FALSE;
    
82.                 }
    
83.                 return TRUE;
    
84.         }
    
85. 
    
86.         // 关闭驱动
    
87.         BOOL Stop()
    
88.         {
    
89.                 SERVICE_STATUS ss;
    
90.                 GetSvcHandle(m_pServiceName);
    
91.                 if (!ControlService(m_hService, SERVICE_CONTROL_STOP, &ss))
    
92.                 {
    
93.                         m_dwLastError = GetLastError();
    
94.                         return FALSE;
    
95.                 }
    
96.                 return TRUE;
    
97.         }
    
98. 
    
99.         // 移除驱动
    
100.         BOOL Remove()
     
101.         {
     
102.                 GetSvcHandle(m_pServiceName);
     
103.                 if (!DeleteService(m_hService))
     
104.                 {
     
105.                         m_dwLastError = GetLastError();
     
106.                         return FALSE;
     
107.                 }
     
108.                 return TRUE;
     
109.         }
     
110. 
     
111.         // 打开驱动
     
112.         BOOL Open(PCHAR pLinkName)
     
113.         {
     
114.                 if (m_hDriver != INVALID_HANDLE_VALUE)
     
115.                         return TRUE;
     
116.                 m_hDriver = CreateFileA(pLinkName, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
     
117.                 if (m_hDriver != INVALID_HANDLE_VALUE)
     
118.                         return TRUE;
     
119.                 else
     
120.                         return FALSE;
     
121.         }
     
122. 
     
123.         // 发送控制信号
     
124.         BOOL IoControl(DWORD dwIoCode, PVOID InBuff, DWORD InBuffLen, PVOID OutBuff, DWORD OutBuffLen, DWORD *RealRetBytes)
     
125.         {
     
126.                 DWORD dw;
     
127.                 BOOL b = DeviceIoControl(m_hDriver, CTL_CODE_GEN(dwIoCode), InBuff, InBuffLen, OutBuff, OutBuffLen, &dw, NULL);
     
128.                 if (RealRetBytes)
     
129.                         *RealRetBytes = dw;
     
130.                 return b;
     
131.         }
     
132. private:
     
133. 
     
134.         // 获取服务句柄
     
135.         BOOL GetSvcHandle(PCHAR pServiceName)
     
136.         {
     
137.                 m_pServiceName = pServiceName;
     
138.                 m_hSCManager = OpenSCManagerA(NULL, NULL, SC_MANAGER_ALL_ACCESS);
     
139.                 if (NULL == m_hSCManager)
     
140.                 {
     
141.                         m_dwLastError = GetLastError();
     
142.                         return FALSE;
     
143.                 }
     
144.                 m_hService = OpenServiceA(m_hSCManager, m_pServiceName, SERVICE_ALL_ACCESS);
     
145.                 if (NULL == m_hService)
     
146.                 {
     
147.                         CloseServiceHandle(m_hSCManager);
     
148.                         return FALSE;
     
149.                 }
     
150.                 else
     
151.                 {
     
152.                         return TRUE;
     
153.                 }
     
154.         }
     
155. 
     
156.         // 获取控制信号对应字符串
     
157.         DWORD CTL_CODE_GEN(DWORD lngFunction)
     
158.         {
     
159.                 return (FILE_DEVICE_UNKNOWN * 65536) | (FILE_ANY_ACCESS * 16384) | (lngFunction * 4) | METHOD_BUFFERED;
     
160.         }
     
161. 
     
162. public:
     
163.         DWORD m_dwLastError;
     
164.         PCHAR m_pSysPath;
     
165.         PCHAR m_pServiceName;
     
166.         PCHAR m_pDisplayName;
     
167.         HANDLE m_hDriver;
     
168.         SC_HANDLE m_hSCManager;
     
169.         SC_HANDLE m_hService;
     
170. };
     
171. 
     
172. void GetAppPath(char *szCurFile)
     
173. {
     
174.         GetModuleFileNameA(0, szCurFile, MAX_PATH);
     
175.         for (SIZE_T i = strlen(szCurFile) - 1; i >= 0; i--)
     
176.         {
     
177.                 if (szCurFile[i] == '\\')
     
178.                 {
     
179.                         szCurFile[i + 1] = '\0';
     
180.                         break;
     
181.                 }
     
182.         }
     
183. }
     
184. 
     
185. // 定义传递结构体
     
186. typedef struct
     
187. {
     
188.         int uuid;
     
189.         char szUname[1024];
     
190. }MyData;
     
191. 
     
192. int main(int argc, char *argv[])
     
193. {
     
194.         cDrvCtrl DriveControl;
     
195. 
     
196.         // 设置驱动名称
     
197.         char szSysFile[MAX_PATH] = { 0 };
     
198.         char szSvcLnkName[] = "WinDDK";;
     
199.         GetAppPath(szSysFile);
     
200.         strcat(szSysFile, "WinDDK.sys");
     
201. 
     
202.         // 安装并启动驱动
     
203.         DriveControl.Install(szSysFile, szSvcLnkName, szSvcLnkName);
     
204.         DriveControl.Start();
     
205. 
     
206.         // 打开驱动的符号链接
     
207.         DriveControl.Open("\\\\.\\WinDDK");
     
208. 
     
209.         // 无参数输出
     
210.         DriveControl.IoControl(IOCTL_IO_Msg, 0, 0, 0, 0, 0);
     
211. 
     
212.         // 传入x参数,返回到y中,返回长度为z
     
213.         DWORD input = 100, output = 0, ref_len = 0;
     
214.         DriveControl.IoControl(IOCTL_IO_TEST, &input, sizeof(input), &output, sizeof(output), &ref_len);
     
215. 
     
216.         std::cout << "传入参数: " << input << std::endl;
     
217.         std::cout << "输出参数: " << output << std::endl;
     
218.         std::cout << "参数长度: " << ref_len << std::endl;
     
219. 
     
220.         // 传入数组
     
221.         int MyArray[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
     
222.         int array_count = 10 * sizeof(int);
     
223. 
     
224.         DriveControl.IoControl(IOCTL_IO_Array, &MyArray, array_count, 0, 0, 0);
     
225. 
     
226.         // 传入一个结构体,返回结构体
     
227.         MyData send_ptr, recv_ptr;
     
228.         DWORD dwSize = 0;
     
229. 
     
230.         memset(send_ptr.szUname, 0, 1024);
     
231.         memset(recv_ptr.szUname, 0, 1024);
     
232. 
     
233.         send_ptr.uuid = 1001;
     
234.         strcpy(send_ptr.szUname, "lyshark");
     
235. 
     
236.         // 派遣命令
     
237.         DriveControl.IoControl(IOCTL_IO_STRUCT, &send_ptr, sizeof(send_ptr), &recv_ptr, sizeof(recv_ptr), &dwSize);
     
238.         // DeviceIoControl(hDevice, IOCTL_IO_STRUCT, &send_ptr, sizeof(send_ptr), (LPVOID)&recv_ptr, sizeof(recv_ptr), &dwSize, 0);
     
239. 
     
240.         std::cout << "内核返回数据: " << recv_ptr.uuid << std::endl;
     
241.         std::cout << "内核返回数据: " << recv_ptr.szUname << std::endl;
     
242.         std::cout << "内核返回长度: " << dwSize << std::endl;
     
243. 
     
244.         // 传入一个字符串,返回一个字符串
     
245.         char szString[256] = { 0 };
     
246.         char szRecvPtr[256] = { 0 };
     
247. 
     
248.         // 派遣命令
     
249.         strcpy(szString, "hello lyshark");
     
250.         DriveControl.IoControl(IOCTL_IO_String, &szString, sizeof(szString), &szRecvPtr, sizeof(szRecvPtr), &dwSize);
     
251.         std::cout << "内核返回数据: " << szRecvPtr << std::endl;
     
252. 
     
253. 
     
254.         // 关闭符号链接句柄
     
255.         CloseHandle(DriveControl.m_hDriver);
     
256. 
     
257.         // 停止并卸载驱动
     
258.         DriveControl.Stop();
     
259.         DriveControl.Remove();
     
260. 
     
261.         system("pause");
     
262.         return 0;
     
263. }

复制代码

手动编译这两个程序，将驱动签名后以管理员身份运行lyshark.exe客户端，此时屏幕中即可看到滚动输出效果，如此一来就实现了循环传递参数的目的。