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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 防火墙与安全工具 > 查看源码
filter.c
资源名称：MyFireWall.rar　[点击查看]
上传用户：zhuzhu0204
上传日期：2020-07-13
资源大小：13165k
文件大小：20k
源码类别：

防火墙与安全工具

开发平台：

Visual C++

filter.c：源码内容
  1. /////////////////////////////////////////////////////
  2. // filter.c文件
  4. // 这个文件包含了驱动程序中过滤相关的代码  过滤部分
  7. #include "precomp.h"
  8. #pragma hdrstop
  10. #include "iocommon.h"
  13. #include "protoinfo.h"
  15. // 过滤规则列表
  16. typedef struct _PassthruFilterList
  17. {
  18. PassthruFilter filter;
  19. struct _PassthruFilterList *pNext;
  21. } PassthruFilterList, *PPassthruFilterList;
  23. // ADAPT结构中FilterReserved部分
  24. typedef struct _ADAPT_FILTER_RSVD
  25. {
  26. BOOLEAN     bFilterInitDone;
  28. //  Per-Adapter过滤相关成员
  29. PassthruStatistics Statistics; // 记录网络状态，如传输了多少封包，丢弃了多少等等
  31. PPassthruFilterList pFilterList; // 指向过滤列表
  33. }ADAPT_FILTER_RSVD, *PADAPT_FILTER_RSVD;
  34. C_ASSERT(sizeof(ADAPT_FILTER_RSVD) <= sizeof(((PADAPT)0)->FilterReserved));
  37. // OPEN_CONTEXT结构中FilterReserved部分.
  38. typedef struct _OPEN_CONTEXT_FILTER_RSVD
  39. {
  40. BOOLEAN     bFilterInitDone;
  42. // 更多的Per-Open-Handle过滤相关成员
  44. }OPEN_FILTER_RSVD, *POPEN_FILTER_RSVD;
  46. C_ASSERT(sizeof(OPEN_FILTER_RSVD) <= sizeof(((POPEN_CONTEXT)0)->FilterReserved));
  48. extern int nWorkMode;
  49. extern BOOLEAN bPingIn;
  50. extern BOOLEAN bPingOut;
  51. ARPRule *pARPRuleList = NULL;
  52. ARPRule *pARPRuleElem = NULL;
  54. VOID FltOnInitAdapter(PADAPT pAdapt)
  55. {
  56. PADAPT_FILTER_RSVD   pFilterContext;
  58. //
  59. // 初始化ADAPT结构中的FilterReserved域
  60. //
  61. pFilterContext = (PADAPT_FILTER_RSVD )&pAdapt->FilterReserved;
  62. }
  65. VOID FltOnDeinitAdapter(PADAPT pAdapt)
  66. {
  67. PADAPT_FILTER_RSVD   pFilterContext;
  69. //
  70. // 反初始化ADAPT结构中的FilterReserved域
  71. //
  72. pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  74. ClearFilterList(pFilterContext);
  75. }
  78. /////////////////////////////////////////////////////
  80. // 向适配器过滤列表中添加一个过滤规则
  81. NTSTATUS AddFilterToAdapter(PADAPT_FILTER_RSVD pFilterContext, PPassthruFilter pFilter)
  82. {
  83. PPassthruFilterList pNew;
  84. // 为新的过滤规则申请内存空间
  85. if(NdisAllocateMemoryWithTag(&pNew, sizeof(PassthruFilterList), TAG) != NDIS_STATUS_SUCCESS)
  86. return STATUS_INSUFFICIENT_RESOURCES;
  88. // 填充这块内存
  89. NdisMoveMemory(&pNew->filter, pFilter, sizeof(PassthruFilter));
  91. // 连接到过滤列表中
  92. pNew->pNext = pFilterContext->pFilterList;
  93. pFilterContext->pFilterList = pNew;
  95. return STATUS_SUCCESS;
  96. }
  98. // 删除适配器过滤列表中的规则
  99. void ClearFilterList(PADAPT_FILTER_RSVD pFilterContext)
  100. {
  101. PPassthruFilterList pList = pFilterContext->pFilterList;
  102. PPassthruFilterList pNext;
  103. // 释放过滤列表占用的内存
  104. while(pList != NULL)
  105. {
  106. pNext = pList->pNext;
  108. NdisFreeMemory(pList, 0, 0); 
  109. pList = pNext;
  110. }
  111. pFilterContext->pFilterList = NULL;
  112. }
  115. // 对那些不能识别的IOCTL，PassThru从主要的DevIoControl例程调用此例程
  117. NTSTATUS FltDevIoControl(PDEVICE_OBJECT pDeviceObject, PIRP pIrp)
  118. {
  119. // 假设失败
  120. NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
  122. // 取得此IRP（pIrp）的I/O堆栈指针
  123. PIO_STACK_LOCATION pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
  125. // 取得I/O控制代码
  126. ULONG uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;
  127. // 取得I/O缓冲区指针和它的长度
  128. PVOID pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;
  129. ULONG uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;
  130. ULONG uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;
  132. ULONG uTransLen = 0;
  134. PADAPT              pAdapt = NULL;
  135.     PADAPT_FILTER_RSVD  pFilterContext = NULL;
  136.     POPEN_CONTEXT       pOpenContext = pIrpStack->FileObject->FsContext;
  138. if(pOpenContext == NULL || (pAdapt = pOpenContext->pAdapt) == NULL)
  139. {
  140. status = STATUS_INVALID_HANDLE;
  141. goto CompleteTheIRP;
  142. }
  144. pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  147. //
  148. // Fail IOCTL If Unbind Is In Progress   Fail IOCTL If Adapter Is Powering Down
  149. //
  150. NdisAcquireSpinLock(&pAdapt->Lock);
  152. if( pAdapt->UnbindingInProcess || pAdapt->StandingBy == TRUE)
  153. {
  154. NdisReleaseSpinLock(&pAdapt->Lock);
  156. status = STATUS_INVALID_DEVICE_STATE;
  157. goto CompleteTheIRP;
  158. }
  160. // 当改变数据时,要拥有SpinLock
  162. // 最后,处理IO控制代码
  163. switch(uIoControlCode)
  164. {
  165. case IOCTL_PTUSERIO_QUERY_STATISTICS: // 获取网络活动状态
  166. {
  167. uTransLen = sizeof(PassthruStatistics);
  168. if(uOutSize < uTransLen)
  169. {
  170. status =  STATUS_BUFFER_TOO_SMALL;
  171. break;
  172. }
  174. NdisMoveMemory(pIoBuffer, &pFilterContext->Statistics, uTransLen);
  176. // 将流速置为0，以方便下一次计算流速
  177. pFilterContext->Statistics.nSendFlowRate = 0;
  178. pFilterContext->Statistics.nRecvFlowRate = 0;
  179. status = STATUS_SUCCESS;
  180. }
  181. break;
  182. case IOCTL_PTUSERIO_RESET_STATISTICS: // 重设网络活动状态
  183. {
  184. NdisZeroMemory(&pFilterContext->Statistics, sizeof(PassthruStatistics));
  185. status = STATUS_SUCCESS;
  186. }
  187. break;
  188. case IOCTL_PTUSERIO_ADD_FILTER: // 添加一个过滤规则
  189. {
  190. if(uInSize >= sizeof(PassthruFilter))
  191. {
  192. status = AddFilterToAdapter(pFilterContext, (PPassthruFilter)pIoBuffer);
  193. }
  194. else
  195. {
  196. status = STATUS_INVALID_DEVICE_REQUEST;
  197. }
  198. }
  199. break;
  200. case IOCTL_PTUSERIO_CLEAR_FILTER: // 清除过滤规则
  201. {
  202. ClearFilterList(pFilterContext);
  203. status = STATUS_SUCCESS;
  204. }
  205. break;
  206. case IOCTL_PTUSERIO_SET_WORKMODE:
  207. {
  208. nWorkMode = *(int *)pIoBuffer;
  209. }
  210. break;
  211. case IOCTL_PTUSERIO_SET_PING:
  212. {
  213. int nPing = *(int *)pIoBuffer;
  214. bPingIn  = (BOOLEAN)nPing/10;
  215. bPingOut = (BOOLEAN)nPing%10;
  216. }
  217. break;
  218. case IOCTL_PTUSERIO_SET_ARP_RULE: // 添加一个过滤规则
  219. {
  220. if(uInSize >= sizeof(ARPRule))
  221. {
  222. ARPRule *pNew;
  223. // 为新的过滤规则申请内存空间
  224. if(NdisAllocateMemoryWithTag(&pNew, sizeof(ARPRule), TAG) != NDIS_STATUS_SUCCESS)
  225. {
  226. return STATUS_INSUFFICIENT_RESOURCES;
  227. }
  229. // 填充这块内存
  230. NdisMoveMemory(pNew, (ARPRule *)pIoBuffer, sizeof(ARPRule));
  232. pNew->pNext = NULL;
  234. // 连接到过滤列表中
  235. if (pARPRuleList == NULL)
  236. {
  237. pARPRuleList = pNew;
  238. pARPRuleElem = pNew;
  239. } 
  240. else
  241. {
  242. pARPRuleElem->pNext = pNew;
  243. pARPRuleElem = pNew;
  244. }
  246. status = STATUS_SUCCESS;
  247. }
  248. else
  249. {
  250. status = STATUS_INVALID_DEVICE_REQUEST;
  251. }
  252. }
  253. break;
  254. case IOCTL_PTUSERIO_CLEAR_ARP_RULE:
  255. {
  256. PARPRule pList = pARPRuleList;
  257. PARPRule pNext;
  258. // 释放过滤列表占用的内存
  259. while(pList != NULL)
  260. {
  261. pNext = pList->pNext;
  262. NdisFreeMemory(pList, 0, 0); 
  263. pList = pNext;
  264. }
  265. pARPRuleList = NULL;
  266. }
  267. break;
  268. }
  271. NdisReleaseSpinLock(&pAdapt->Lock);
  273. CompleteTheIRP:
  275. if(status == STATUS_SUCCESS)
  276. pIrp->IoStatus.Information = uTransLen;
  277. else
  278. pIrp->IoStatus.Information = 0;
  280. pIrp->IoStatus.Status = status;
  281. IoCompleteRequest(pIrp, IO_NO_INCREMENT);
  282. return status;
  283. }
  286. ////////////////////////////////////////////////////
  287. // 读取封包中的数据
  288. void FltReadPacketData(PNDIS_PACKET pPacket, 
  289.    PUCHAR lpBufferIn, ULONG nNumberToRead, PUINT lpNumberOfRead)
  290. {
  291. PUCHAR pBuf;
  292. ULONG nBufferSize;
  293. PNDIS_BUFFER pBufferDes = NULL;
  295. // 检查参数
  296. if(pPacket == NULL || lpBufferIn == NULL || nNumberToRead == 0)
  297. {
  298. if(lpNumberOfRead != NULL)
  299. {
  300. *lpNumberOfRead = 0;
  301. }
  302. return ;
  303. }
  305. // 设置返回数据
  306. *lpNumberOfRead = 0;
  308. // 遍历封包中的缓冲区描述表,将数据复制到用户缓冲区
  309. pBufferDes = pPacket->Private.Head;
  310. while (pBufferDes != NULL)
  311. {
  312. // 获取此缓冲区描述表的缓冲区信息
  313. NdisQueryBufferSafe(pBufferDes, &pBuf, &nBufferSize, NormalPagePriority);
  314. if(pBuf == NULL)
  315. {
  316. return;
  317. }
  319. if(nNumberToRead > nBufferSize) // 复制整个缓冲区
  320. {
  321. NdisMoveMemory(lpBufferIn + *lpNumberOfRead, pBuf, nBufferSize);
  322. nNumberToRead -= nBufferSize;
  323. *lpNumberOfRead += nBufferSize;
  324. }
  325. else // 仅复制剩下的部分
  326. {
  327. NdisMoveMemory(lpBufferIn + *lpNumberOfRead, pBuf, nNumberToRead);
  328. *lpNumberOfRead += nNumberToRead;
  329. return;
  330. }
  331. if (pBufferDes == pPacket->Private.Tail)
  332. {
  333. break;
  334. }
  335. // 下一个缓冲区描述表
  336. pBufferDes = pBufferDes->Next;
  337. }
  338. }
  340. /////////////////////////////////////////////
  342. // 检查ARP过滤规则
  343. BOOLEAN FltCheckARPRules(ARPHeader *pArpHdr, BOOLEAN bIsIn)
  344. {
  345. ARPRule *p;
  347. if (pARPRuleList == NULL)
  348. {
  349. return TRUE;
  350. }
  352. if (bIsIn == TRUE)
  353. {
  354. // 接收ARP数据包，检查源IP地址和源MAC
  355. for (p=pARPRuleList; p!=NULL; p=p->pNext)
  356. {
  357. if (memcmp(pArpHdr->saddr, p->ucIP, sizeof(UCHAR)*4) == 0 && memcmp(pArpHdr->smac, p->ucMac, sizeof(UCHAR)*6) == 0)
  358. {
  359. // 该ARP数据包中的源IP地址和源MAC与ARP规则表中的某一项一致，说明该ARP数据包正常
  360. return TRUE;
  361. }
  362. }
  364. // 执行到此，说明该ARP数据包中的源IP地址和源MAC与ARP规则表中所有项都不一致，该ARP数据包不正常
  365. return FALSE;
  366. }
  367. else
  368. {
  369. // 发送ARP数据包，检查源IP地址和源MAC是否与本机的相同，这样是为了防止本机发送ARP欺骗包
  370. // 我们预设的本机源IP地址和源MAC保存在ARP规则链表的头节点处
  371. // if (memcmp(pArpHdr->saddr, pARPRuleList->ucIP, sizeof(UCHAR)*4) == 0 && memcmp(pArpHdr->smac, pARPRuleList->ucMac, sizeof(UCHAR)*6) == 0)
  372. if (pArpHdr->saddr[0] == pARPRuleList->ucIP[0] && pArpHdr->saddr[1] == pARPRuleList->ucIP[1] && pArpHdr->saddr[2] == pARPRuleList->ucIP[2] && pArpHdr->saddr[3] == pARPRuleList->ucIP[3] &&
  373. pArpHdr->smac[0] == pARPRuleList->ucMac[0] && pArpHdr->smac[1] == pARPRuleList->ucMac[1] && pArpHdr->smac[2] == pARPRuleList->ucMac[2] &&
  374. pArpHdr->smac[3] == pARPRuleList->ucMac[3] && pArpHdr->smac[4] == pARPRuleList->ucMac[4] && pArpHdr->smac[5] == pARPRuleList->ucMac[5] 
  375. )
  376. {
  377. // 该ARP数据包中的源IP地址和源MAC与ARP规则表中的某一项一致，说明该ARP数据包正常
  378. return TRUE;
  379. }
  380. else
  381. {
  382. return FALSE;
  383. }
  385. return TRUE;
  386. }
  387. }
  389. // 检查总体过滤规则
  390. BOOLEAN FltCheckFilterRules(PPassthruFilterList pFilterList, PUCHAR pPacketData, ULONG nDataLen, BOOLEAN bIncludeETHdr, BOOLEAN bIsIn, BOOLEAN bIsARPPacket)
  391. {
  392. int nLeavingLen = nDataLen;
  394. PETHeader pEtherHdr;
  395. PIPHeader pIpHdr;
  396. PARPHeader pArpHdr;
  397. PTCPHeader pTcpHdr;
  398. PUDPHeader pUdpHdr;
  399. PICMPHeader pIcmpHdr;
  401. // 从缓冲区中萃取出IP头
  402. // 如果包含以太头，就要先检查以太头
  403. if(bIncludeETHdr)
  404. {
  405. if(nLeavingLen < sizeof(ETHeader))
  406. {
  407. return TRUE;
  408. }
  409. nLeavingLen -= sizeof(ETHeader);
  411. pEtherHdr = (PETHeader)pPacketData;
  412. if (pEtherHdr->type == 0X0608)
  413. {
  414. // 是ARP数据包
  415. pArpHdr = (PARPHeader)(pEtherHdr + 1);
  416. return FltCheckARPRules(pArpHdr, bIsIn);
  417. } 
  418. else if (pEtherHdr->type == 0X0008)
  419. {
  420. // 是IP数据包
  421. pIpHdr = (PIPHeader)(pEtherHdr + 1);
  422. }
  423. else
  424. {
  425. // 如果不是IP协议或ARP协议，则不处理
  426. return TRUE;
  427. }
  428. }
  429. else
  430. {
  431. if (bIsARPPacket == TRUE)
  432. {
  433. pArpHdr = (PARPHeader)pPacketData;
  434. return FltCheckARPRules(pArpHdr, bIsIn);
  435. } 
  436. else
  437. {
  438. pIpHdr = (PIPHeader)pPacketData;
  439. }
  441. }
  443. // 验证剩余数据长度，防止发生内核非法访问
  444. if(nLeavingLen < sizeof(IPHeader))
  445. return TRUE;
  446. nLeavingLen -= sizeof(IPHeader);
  449. // 检查版本信息，我们仅处理IPv4
  450. if(((pIpHdr->iphVerLen >> 4) & 0x0f) == 6)
  451. {
  452. return TRUE;
  453. }
  455. if(pIpHdr->ipProtocol == 6 && nLeavingLen >= sizeof(TCPHeader))  // 是TCP协议？
  456. {
  457. // 提取TCP头
  458. pTcpHdr = (PTCPHeader)(pIpHdr + 1);
  459. // 我们接受所有已经建立连接的TCP封包
  460. if(!(pTcpHdr->flags & 0x02))
  461. {
  462. return TRUE;
  463. }
  464. }
  466. // 与过滤规则比较，决定采取的行动
  467. while(pFilterList != NULL)
  468. {
  469. // 查看封包使用的协议是否和过滤规则相同
  470. if(pFilterList->filter.protocol == 0 || pFilterList->filter.protocol == pIpHdr->ipProtocol)
  471. {
  472. // 如果协议相同，再查看源IP地址
  473. if(pFilterList->filter.sourceIP != 0 && pFilterList->filter.sourceIP != pIpHdr->ipSource)
  474. {
  475. pFilterList = pFilterList->pNext;
  476. continue;
  477. }
  479. // 再查看目的IP地址
  480. if(pFilterList->filter.destinationIP != 0 && pFilterList->filter.destinationIP != pIpHdr->ipDestination)
  481. {
  482. pFilterList = pFilterList->pNext;
  483. continue;
  484. }
  486. // 如果是TCP封包，接着查看TCP端口号
  487. if(pIpHdr->ipProtocol == 6)
  488. {
  489. if(nLeavingLen < 4)
  490. {
  491. return TRUE;
  492. }
  493. pTcpHdr = (PTCPHeader)(pIpHdr + 1);
  494. // 如果源端口号和目的端口号都与规则中的一样，则按照规则的记录处理这个封包
  495. if(pFilterList->filter.sourcePort == 0 || pFilterList->filter.sourcePort == pTcpHdr->sourcePort)
  496. {
  497. if(pFilterList->filter.destinationPort == 0 ||
  498. pFilterList->filter.destinationPort == pTcpHdr->destinationPort)
  499. {
  500. return !pFilterList->filter.bDrop; 
  501. }
  502. }
  504. }
  505. // 如果是UDP封包，接着查看UDP端口号
  506. else if(pIpHdr->ipProtocol == 17)
  507. {
  508. if(nLeavingLen < 4)
  509. {
  510. // return !pFilterList->filter.bDrop;
  511. return TRUE;
  512. }
  513. pUdpHdr = (PUDPHeader)(pIpHdr + 1);
  515. if(pFilterList->filter.sourcePort == 0 || 
  516. pFilterList->filter.sourcePort == pUdpHdr->sourcePort)
  517. {
  518. if(pFilterList->filter.destinationPort == 0 ||
  519. pFilterList->filter.destinationPort == pUdpHdr->destinationPort)
  520. {
  521. return !pFilterList->filter.bDrop; 
  522. }
  523. }
  524. }
  525. // 如果是ICMP封包，则判断Ping入和Ping出
  526. else if(pIpHdr->ipProtocol == 1)
  527. {
  528. // 禁止Ping入
  529. if (bPingIn == FALSE && bIsIn == TRUE)
  530. {
  531. pIcmpHdr = (PICMPHeader)(pIpHdr + 1);
  532. if (pIcmpHdr->type == 8 && pIcmpHdr->code == 0) // 这对应的是Echo Request(Echo 请求)ICMP封包
  533. {
  534. return FALSE;
  535. }
  536. }
  538. // 禁止Ping出
  539. if (bPingOut == FALSE && bIsIn == FALSE)
  540. {
  541. pIcmpHdr = (PICMPHeader)(pIpHdr + 1);
  542. if (pIcmpHdr->type == 8 && pIcmpHdr->code == 0) // 这对应的是Echo Request(Echo 请求)ICMP封包
  543. {
  544. return FALSE;
  545. }
  546. }
  547. }
  548. else
  549. {
  550. // 对于其它封包，我们直接处理
  551. return !pFilterList->filter.bDrop; 
  552. }
  553. }
  554. // 比较下一个封包
  555. pFilterList = pFilterList->pNext;
  556. }
  558. // 默认情况下接收所有封包
  559. return TRUE;
  560. }
  562. ULONG GetPacketFlowRate(PUCHAR pPacketData, ULONG nDataLen)
  563. {
  564. int nLeavingLen = nDataLen;
  566. PETHeader pEtherHdr;
  567. PIPHeader pIpHdr;
  569. if(nLeavingLen < sizeof(ETHeader))
  570. {
  571. return TRUE;
  572. }
  573. nLeavingLen -= sizeof(ETHeader);
  575. pEtherHdr = (PETHeader)pPacketData;
  577. if (pEtherHdr->type == 0X0608)
  578. {
  579. // 是ARP数据包
  580. return 28; // 28是ARP协议头的长度
  582. } 
  583. else if (pEtherHdr->type == 0X0008)
  584. {
  585. // 是IP数据包
  586. pIpHdr = (PIPHeader)(pEtherHdr + 1);
  588. // 验证剩余数据长度，防止发生内核非法访问
  589. if(nLeavingLen < sizeof(IPHeader))
  590. {
  591. return 0;
  592. }
  593. nLeavingLen -= sizeof(IPHeader);
  596. // 检查版本信息，我们仅处理IPv4
  597. if(((pIpHdr->iphVerLen >> 4) & 0x0f) == 6)
  598. {
  599. return 0;
  600. }
  602. // 返回流量信息
  603. return pIpHdr->ipLength;
  604. }
  605. }
  607. // 过滤向外发送的数据，从MPSendPackets或者MPSend函数调用
  608. // 如果从MPSendPackets调用就运行在IRQL <= DISPATCH_LEVEL级别
  609. // 如果从MPSend调用，就运行在IRQL == DISPATCH_LEVEL级别
  610. BOOLEAN FltFilterSendPacket(
  611. IN PADAPT          pAdapt,
  612. IN PNDIS_PACKET    pSendPacket,
  613. IN BOOLEAN         bDispatchLevel  // TRUE -> IRQL == DISPATCH_LEVEL
  614. )
  615. {
  616. BOOLEAN bPass = TRUE;
  617. PADAPT_FILTER_RSVD pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  618. UCHAR buffer[MAX_PACKET_HEADER_LEN];
  619. ULONG nReadBytes;
  621. // 当使用过滤数据时，要获取旋转锁
  622. if(bDispatchLevel)
  623. {
  624. NdisDprAcquireSpinLock(&pAdapt->Lock);
  625. }
  626. else
  627. {
  628. NdisAcquireSpinLock(&pAdapt->Lock);
  629. }
  631. // 设置统计数字
  632. pFilterContext->Statistics.nMPSendPktsCt ++;
  634. // 读取封包中的数据，这里仅读取封包头即可
  635. FltReadPacketData(pSendPacket, buffer, MAX_PACKET_HEADER_LEN, &nReadBytes);
  637. // 设置发送流量信息
  638. if (pFilterContext->Statistics.nSendFlowRate > 40000000000)
  639. {
  640. // unsigned long类型的范围是：0 - 4,294,967,295
  641. // 这样做保证不会出现错误
  642. pFilterContext->Statistics.nSendFlowRate = 0;
  643. }
  644. pFilterContext->Statistics.nSendFlowRate += GetPacketFlowRate(buffer, nReadBytes);
  646. // 如果没有设置过滤规则，则放行所有封包
  647. if(nWorkMode == IM_PASS_ALL)
  648. {
  649. goto ExitTheFilter;
  650. }
  651. else if (nWorkMode == IM_DENY_ALL)
  652. {
  653. bPass = FALSE;
  654. }
  655. else if (pFilterContext->pFilterList == NULL)
  656. {
  657. goto ExitTheFilter;
  658. }
  659. else
  660. {
  661. // 检查过滤规则，看看是否允许这个封包通过
  662. bPass = FltCheckFilterRules(pFilterContext->pFilterList, buffer, nReadBytes, TRUE, FALSE, FALSE);
  663. }
  664. if(!bPass)
  665. {
  666. // 拒绝了一个封包
  667. pFilterContext->Statistics.nMPSendPktsDropped ++;
  668. }
  670. ExitTheFilter:
  671. // 过滤之后要释放旋转锁
  672. if(bDispatchLevel)
  673. NdisDprReleaseSpinLock(&pAdapt->Lock);
  674. else
  675. NdisReleaseSpinLock(&pAdapt->Lock);
  677. return bPass;
  678. }
  682. // 过滤接收到的数据,从PtReceivePacket函数调用，运行在DISPATCH_LEVEL IRQL级别
  683. BOOLEAN FltFilterReceivePacket(
  684. IN PADAPT         pAdapt,
  685. IN PNDIS_PACKET   pReceivedPacket
  686. )
  687. {
  688. BOOLEAN bPass = TRUE;
  689. PADAPT_FILTER_RSVD pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  690. UCHAR buffer[MAX_PACKET_HEADER_LEN];
  691. ULONG nReadBytes;
  693. // 当使用过滤数据时，要获取旋转锁
  694. NdisDprAcquireSpinLock(&pAdapt->Lock);
  696. // 设置统计数字
  697. pFilterContext->Statistics.nPTRcvPktCt ++;
  699. // 读取封包中的数据，这里仅读取封包头即可
  700. FltReadPacketData(pReceivedPacket, buffer, MAX_PACKET_HEADER_LEN, &nReadBytes);
  701. if(nReadBytes != MAX_PACKET_HEADER_LEN)
  702. {
  703. }
  705. // 设置接收流量信息
  706. if (pFilterContext->Statistics.nRecvFlowRate > 40000000000)
  707. {
  708. // unsigned long类型的范围是：0 - 4,294,967,295
  709. // 这样做保证不会出现错误
  710. pFilterContext->Statistics.nRecvFlowRate = 0;
  711. }
  713. pFilterContext->Statistics.nRecvFlowRate += GetPacketFlowRate(buffer, nReadBytes);
  715. // 如果没有设置过滤规则，则放行所有封包
  716. if(nWorkMode == IM_PASS_ALL)
  717. {
  718. goto ExitTheFilter;
  719. }
  720. else if (nWorkMode == IM_DENY_ALL)
  721. {
  722. bPass = FALSE;
  723. }
  724. else if (pFilterContext->pFilterList == NULL)
  725. {
  726. goto ExitTheFilter;
  727. }
  728. else
  729. {
  730. // 检查过滤规则，看看是否允许这个封包通过
  731. bPass = FltCheckFilterRules(pFilterContext->pFilterList,buffer, nReadBytes, TRUE, TRUE, FALSE);
  732. }
  733. if(!bPass)
  734. {
  735. // 拒绝了一个封包
  736. pFilterContext->Statistics.nPTRcvPktDropped ++;
  737. }
  739. ExitTheFilter:
  740. // 过滤之后要释放旋转锁
  741. NdisDprReleaseSpinLock(&pAdapt->Lock);
  743. return bPass;
  744. }
  746. // 过滤接收到的数据,从PtReceivePacket函数调用，运行在DISPATCH_LEVEL IRQL级别
  747. BOOLEAN FltFilterReceive(
  748. IN PADAPT         pAdapt,
  749. IN NDIS_HANDLE    MacReceiveContext,
  750. IN PVOID          HeaderBuffer,
  751. IN UINT           HeaderBufferSize,
  752. IN PVOID          LookAheadBuffer,
  753. IN UINT           LookAheadBufferSize,
  754. IN UINT           PacketSize
  755. )
  756. {
  757. BOOLEAN bPass = TRUE;
  758. PADAPT_FILTER_RSVD pFilterContext = (PADAPT_FILTER_RSVD)&pAdapt->FilterReserved;
  759. PETHeader pEtherHdr = (PETHeader)HeaderBuffer;
  760. BOOLEAN bIsARPPacket = FALSE;
  762. // 当使用过滤数据时，要获取旋转锁
  763. NdisDprAcquireSpinLock(&pAdapt->Lock);
  765. // 设置统计数字
  766. pFilterContext->Statistics.nPTRcvCt ++;
  768. // 设置接收流量
  769. if (pFilterContext->Statistics.nRecvFlowRate > 40000000000)
  770. {
  771. // unsigned long类型的范围是：0 - 4,294,967,295
  772. // 这样做保证不会出现错误
  773. pFilterContext->Statistics.nRecvFlowRate = 0;
  774. }
  775. pFilterContext->Statistics.nRecvFlowRate += PacketSize;
  777. // 如果过滤规则是“允许所有”或没有设置过滤规则，则放行所有封包
  778. if(nWorkMode == IM_PASS_ALL)
  779. {
  780. goto ExitTheFilter;
  781. }
  782. else if (nWorkMode == IM_DENY_ALL)
  783. {
  784. bPass = FALSE;
  785. }
  786. else
  787. {
  788. if (pEtherHdr->type == 0X0608)
  789. {
  790. // ARP数据包
  791. bPass = FltCheckFilterRules(pFilterContext->pFilterList,LookAheadBuffer, LookAheadBufferSize, FALSE, TRUE, TRUE);
  792. goto ExitTheFilter;
  793. } 
  794. else if (pEtherHdr->type == 0X0008)
  795. {
  796. // IP数据包
  797. if (pFilterContext->pFilterList == NULL)
  798. {
  799. goto ExitTheFilter;
  800. }
  801. else
  802. {
  803. // 检查过滤规则，看看是否允许这个封包通过
  804. bPass = FltCheckFilterRules(pFilterContext->pFilterList,LookAheadBuffer, LookAheadBufferSize, FALSE, TRUE, FALSE);
  805. }
  806. }
  807. else
  808. {
  809. // 如果不是IP协议或ARP协议，则放行
  810. goto ExitTheFilter;
  811. }
  812. }
  814. if(!bPass)
  815. {
  816. // 拒绝了一个封包
  817. pFilterContext->Statistics.nPTRcvDropped ++;
  818. }
  820. ExitTheFilter:
  821. // 过滤之后要释放旋转锁
  822.     NdisDprReleaseSpinLock(&pAdapt->Lock);
  824. return bPass;
  825. }