开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 防火墙与安全工具 > 查看源码
IpHookGlobal.cpp
资源名称：ipfilter.zip　[点击查看]
上传用户：nnxzhh
上传日期：2007-01-11
资源大小：742k
文件大小：8k
源码类别：

防火墙与安全工具

开发平台：

WINDOWS

IpHookGlobal.cpp：源码内容
  1. ///////////////////////////////////////////////////////////////////////////////
  2. //
  3. // (C) Copyright 1999 - 2000 Mark Roddy
  4. // All Rights Reserved
  5. //
  6. // Hollis Technology Solutions
  7. // 94 Dow Road
  8. // Hollis, NH 03049
  9. // info@hollistech.com
  10. //
  11. // Synopsis: 
  12. // 
  13. //
  14. // Version Information:
  15. //
  16. // $Header: /iphook/sys/driver/IpHookGlobal.cpp 4     1/27/00 10:35p Markr $ 
  17. //
  18. ///////////////////////////////////////////////////////////////////////////////
  19. #include "IpHookKrnl.h"
  21. HTS_DEBUG_THIS_FILE
  23. void IP_HOOK_GLOBAL_DATA::queueRequest(PIRP Irp)
  24. {
  25. PVOID context;
  27. lock(context);
  28. IoSetCancelRoutine(Irp, GlobalCancel);
  29. InsertTailList(&queue, &Irp->Tail.Overlay.ListEntry);
  30. unlock(context);
  31. }
  33. PIRP IP_HOOK_GLOBAL_DATA::popQueue(BOOLEAN locked)
  34. {
  35. PIRP Irp = NULL;
  37. PVOID context;
  39. if (!locked) {
  41. lock(context);
  42. }
  44. if (!IsListEmpty(&queue)) {
  46. PLIST_ENTRY el = RemoveHeadList(&queue);
  47. Irp = CONTAINING_RECORD(el, IRP, Tail.Overlay.ListEntry);
  48. PDRIVER_CANCEL state = IoSetCancelRoutine(Irp, NULL);
  50. if (state == NULL) {
  51. //
  52. // we have hit the race condition where our
  53. // cancel routine is runnning just before it acquires
  54. // the lock and dequeues the irp
  55. //
  56. InsertHeadList(&cancelQueue, &Irp->Tail.Overlay.ListEntry);
  58. Irp = NULL;
  59. }
  61.     }
  63. if (!locked) {
  65. unlock(context);
  67. }
  69. return Irp;
  70. }
  72. PIPHOOK_DATA IP_HOOK_GLOBAL_DATA::getBuffer()
  73. {
  74. PIPHOOK_DATA data = NULL;
  76. HtsDebugPrint(HTS_DEBUG_LOW, "getBuffer()n");
  78. PVOID context;
  80. lock(context);
  82. bool keepTrying = true;
  84. do {
  86. if (currentBuffer == NULL) {
  88. HtsAssert(currentIrp == NULL);
  90. currentIrp = popQueue(TRUE);
  92. if (currentIrp) {
  94. currentBuffer = 
  95. (PIPHOOK_BUFFER) MmGetSystemAddressForMdl(currentIrp->MdlAddress);
  96. }
  98. if (currentBuffer) {
  100. currentBuffer->valid = 0;
  102. }  else {
  104. keepTrying =false;
  106. }
  107. }
  109. if (currentBuffer) {
  111. HtsDebugPrint(HTS_DEBUG_LOW, "currentBuffer %x valid %x entries %xn",
  112. currentBuffer,
  113. currentBuffer->valid, currentBuffer->entries);
  115. if (currentBuffer->valid < currentBuffer->entries) {
  117. data = &currentBuffer->buffer[currentBuffer->valid];
  119. currentBuffer->valid++;
  121. } else {
  123. flushBuffer(TRUE);
  125. HtsAssert(currentBuffer == NULL);
  126. //
  127. // Im tempted to recurse here
  128. //
  129. HtsDebugPrint(HTS_DEBUG_LOW, "getBuffer continuen");
  131. }
  132. }
  134. } while ((!currentBuffer) && keepTrying);
  136. unlock(context);
  138. HtsDebugPrint(HTS_DEBUG_LOW, "returning data %xn", data);
  140. return data;
  141. }
  143. IP_HOOK_GLOBAL_DATA::IP_HOOK_GLOBAL_DATA() 
  144. {
  145. owningContext = NULL;
  146. IpfDeviceObject = NULL;
  147. IpfFileObject = NULL;
  148. IpHookSequence = 0;
  149. InitializeListHead(&queue);
  150. InitializeListHead(&cancelQueue);
  151. currentIrp = NULL;
  152. currentBuffer = NULL;
  153. KeInitializeEvent(&stopEvent, NotificationEvent, FALSE);
  155. }
  157. NTSTATUS IP_HOOK_GLOBAL_DATA::initDevice()
  158. {
  159. UNICODE_STRING nameString;
  161. RtlInitUnicodeString(&nameString, DD_IPFLTRDRVR_DEVICE_NAME);
  163. NTSTATUS Status = IoGetDeviceObjectPointer(&nameString,
  164.   STANDARD_RIGHTS_ALL,
  165.   &IpfFileObject,
  166.   &IpfDeviceObject);
  167. if (!NT_SUCCESS(Status)) {
  169. HtsDebugPrint(HTS_DEBUG_HIGH, "Can't open IpFilter (%S) Status %xn",
  170.   DD_IPFLTRDRVR_DEVICE_NAME, Status);
  172. } else {
  174. HtsAssert( IpfFileObject );
  176. HtsAssert( IpfDeviceObject );
  177. }
  179. return Status;
  180. }
  183. IP_HOOK_GLOBAL_DATA::~IP_HOOK_GLOBAL_DATA()
  184. {
  185. HtsDebugPrint(HTS_DEBUG_LOW, 
  186. "~IP_HOOK_GLOBAL_DATA IpfFileObject %xn", IpfFileObject);
  188. if (workerThreadObject != NULL) {
  190. KeSetEvent(&stopEvent, 0, TRUE);
  192. (void) KeWaitForSingleObject(workerThreadObject, Executive, KernelMode, FALSE, NULL);
  194. ObDereferenceObject(workerThreadObject);
  195.         
  196. }
  199. if (IpfFileObject) {
  201. HtsAssert(IpfDeviceObject);
  203. ObDereferenceObject(IpfFileObject);
  204. IpfFileObject = NULL;
  205. IpfDeviceObject = NULL;
  207. } else {
  209. HtsAssert(ipGlobal.IpfDeviceObject == NULL);
  211. }
  214. }
  216. void IP_HOOK_GLOBAL_DATA::flushBufferIfData()
  217. {
  218. PVOID context;
  220. lock(context);
  222. if (currentIrp) {
  224. HtsAssert(currentBuffer);
  226. if (currentBuffer->valid) {
  228. flushBuffer(TRUE);
  229. }
  230. }
  232. unlock(context);
  233. }
  235. void IP_HOOK_GLOBAL_DATA::flushBuffer(BOOLEAN locked)
  236. {
  237. //
  238. // complete the current buffer/irp
  239. //
  240. PIRP Irp = NULL;
  241. ULONG Information = 0;
  242. PVOID context;
  244. HtsDebugPrint(HTS_DEBUG_LOW, "flushBuffer(%x)n", locked);
  246. if (!locked) {
  248. lock(context);
  249. }
  251. if (currentIrp) {
  253. HtsAssert(currentBuffer);
  255. Irp = currentIrp;
  257. currentIrp = NULL;
  259. ULONG valid = currentBuffer->valid;
  261. Information = sizeof(IPHOOK_BUFFER) - sizeof(IPHOOK_DATA)
  262. + (valid * sizeof(IPHOOK_DATA));
  264. currentBuffer = NULL;
  266. HtsDebugPrint(HTS_DEBUG_LOW, "Flushing Irp %x valid %x size %xn", Irp, valid, Information);
  268. }
  270. if (!locked) {
  272. unlock(context);
  274. }
  276. if (Irp) {
  278. HtsIrpReturn(Irp, STATUS_SUCCESS, Information);
  279. }
  280. }
  282. void IP_HOOK_GLOBAL_DATA::releaseAllBuffers(BOOLEAN locked)
  283. {
  284. flushBuffer(locked);
  286. PIRP Irp = popQueue(locked);
  288. HtsDebugPrint(HTS_DEBUG_LOW, "releaseAllBuffers(%d)n", locked);
  290. while (Irp) {
  292. HtsDebugPrint(HTS_DEBUG_LOW, "releasing Irp %xn", Irp);
  294. HtsIrpReturn(Irp, STATUS_CANCELLED, 0);
  296. Irp = popQueue(locked);
  297. }
  298. }
  300. void workerThreadStart(PVOID context)
  301. {
  302. //
  303. // this routine runs forever until it is signalled to die.
  304. // It waits on an event - the stopevent, the wait is timed.
  305. // If the timer expires then the function flushes the current buffer - 
  306. // delivering the contents to user space. Otherwise the routine terminates
  307. // its host thread by returning out of this function.
  308. //
  309. PRKEVENT stopEvent = (PRKEVENT) context;
  310. LARGE_INTEGER  Timeout;
  312. do {
  313. Timeout.QuadPart = -10000000L;
  315. NTSTATUS Status = KeWaitForSingleObject(stopEvent,
  316.   Executive,
  317.   KernelMode,
  318.   FALSE,
  319.   &Timeout);
  321. switch (Status) {
  323. case STATUS_TIMEOUT:
  324. //
  325. // flush the buffer
  326. //
  327. HtsDebugPrint(HTS_DEBUG_LOW, "workerThreadStart STATUS_TIMEOUTn");
  328. ipGlobal.flushBufferIfData();
  330. break;
  332. default:
  334. HtsDebugPrint(HTS_DEBUG_HIGH,
  335. "workerThreadStart wait returned %xn", Status);
  337. case STATUS_SUCCESS:
  338. //
  339. // for any value other than STATUS_TIMEOUT we bail!
  340. //
  341. HtsDebugPrint(HTS_DEBUG_LOW,
  342. "workerThreadStart exitn");
  344. return;
  345. }
  347. } while(1);
  349. }
  351. NTSTATUS IP_HOOK_GLOBAL_DATA::createThread()
  352. {
  354. NTSTATUS Status = PsCreateSystemThread(&workerThread,
  355.   THREAD_ALL_ACCESS,
  356.   NULL,
  357.   NULL,
  358.   NULL,
  359.   workerThreadStart,
  360.   (PVOID)&stopEvent);
  362. if (!NT_SUCCESS(Status)) {
  364. HtsDebugPrint(HTS_DEBUG_HIGH, "PsCreateSystemThread failedn");
  366. workerThread = NULL;
  368. }
  370. Status = ObReferenceObjectByHandle(workerThread, THREAD_ALL_ACCESS, NULL, KernelMode,
  371.   &workerThreadObject, NULL );
  373. if (!NT_SUCCESS(Status)) {
  375. HtsDebugPrint(HTS_DEBUG_HIGH, "ObReferenceObjectByHandle failedn");
  377. KeSetEvent(&stopEvent, 0, FALSE);
  379. workerThread = NULL;
  381. workerThreadObject = NULL;
  383. }
  385. return Status;
  387. }
  388. ///////////////////////////////////////////////////////////////////////////////
  389. // 
  390. // Change History Log
  391. //
  392. // $Log: /iphook/sys/driver/IpHookGlobal.cpp $
  393. // 
  394. // 4     1/27/00 10:35p Markr
  395. // Prepare to release!
  396. //
  397. ///////////////////////////////////////////////////////////////////////////////