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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 防火墙与安全工具 > 查看源码
MainFrm.cpp
资源名称：IPbao.rar　[点击查看]
上传用户：ykzxjx
上传日期：2022-04-03
资源大小：1175k
文件大小：10k
源码类别：

防火墙与安全工具

开发平台：

Visual C++

MainFrm.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/usr/IpMonitor/MainFrm.cpp 3     1/27/00 10:35p Markr $ 
  17. //
  18. ///////////////////////////////////////////////////////////////////////////////
  19. // MainFrm.cpp : implementation of the CMainFrame class
  20. //
  22. #include "stdafx.h"
  23. #include "IpMonitor.h"
  24. #include "MainFrm.h"
  25. #include "winioctl.h"
  27. #ifdef _DEBUG
  28. #define new DEBUG_NEW
  29. #undef THIS_FILE
  30. static char THIS_FILE[] = __FILE__;
  31. #endif
  33. /////////////////////////////////////////////////////////////////////////////
  34. // CMainFrame
  36. IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)
  38. BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
  39. //{{AFX_MSG_MAP(CMainFrame)
  40. ON_WM_CREATE()
  41. ON_COMMAND(START_HOOK, OnStartHook)
  42. ON_COMMAND(STOP_HOOK, OnStopHook)
  43. ON_UPDATE_COMMAND_UI(START_HOOK, OnUpdateStartHook)
  44. ON_UPDATE_COMMAND_UI(STOP_HOOK, OnUpdateStopHook)
  45. ON_MESSAGE(BUFFER_AVAILABLE_MSG, OnBufferMessage)
  46. //}}AFX_MSG_MAP
  47. // Global help commands
  48. ON_COMMAND(ID_HELP_FINDER, CFrameWnd::OnHelpFinder)
  49. ON_COMMAND(ID_HELP, CFrameWnd::OnHelp)
  50. ON_COMMAND(ID_CONTEXT_HELP, CFrameWnd::OnContextHelp)
  51. ON_COMMAND(ID_DEFAULT_HELP, CFrameWnd::OnHelpFinder)
  52. END_MESSAGE_MAP()
  54. static UINT indicators[] =
  55. {
  56. ID_SEPARATOR,           // status line indicator
  57. ID_INDICATOR_CAPS,
  58. ID_INDICATOR_NUM,
  59. ID_INDICATOR_SCRL,
  60. };
  62. /////////////////////////////////////////////////////////////////////////////
  63. // CMainFrame construction/destruction
  65. CMainFrame::CMainFrame()
  66. {
  67. m_Enabled = FALSE;
  68. m_Started = FALSE;
  71. }
  73. CMainFrame::~CMainFrame()
  74. {
  75. }
  77. int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
  78. {
  79. if ((theApp.hookDriver.handle() == INVALID_HANDLE_VALUE) ||
  80. (theApp.filterDriver.handle() == INVALID_HANDLE_VALUE)) {
  82. m_Started = FALSE;
  83. m_Enabled = FALSE;
  85. } else {
  87. m_Started = FALSE;
  88. m_Enabled = TRUE;
  90. }
  92. if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
  93. return -1;
  95. if (!m_wndStatusBar.Create(this) ||
  96. !m_wndStatusBar.SetIndicators(indicators,
  97.   sizeof(indicators)/sizeof(UINT)))
  98. {
  99. TRACE0("Failed to create status barn");
  100. return -1;      // fail to create
  101. }
  103. return 0;
  104. }
  106. BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
  107. {
  108. if( !CFrameWnd::PreCreateWindow(cs) )
  109. return FALSE;
  110. // TODO: Modify the Window class or styles here by modifying
  111. //  the CREATESTRUCT cs
  113. return TRUE;
  114. }
  116. /////////////////////////////////////////////////////////////////////////////
  117. // CMainFrame diagnostics
  119. #ifdef _DEBUG
  120. void CMainFrame::AssertValid() const
  121. {
  122. CFrameWnd::AssertValid();
  123. }
  125. void CMainFrame::Dump(CDumpContext& dc) const
  126. {
  127. CFrameWnd::Dump(dc);
  128. }
  130. #endif //_DEBUG
  132. /////////////////////////////////////////////////////////////////////////////
  133. // CMainFrame message handlers
  136. void CMainFrame::OnStartHook() 
  137. {
  138. if (theApp.hookDriver.handle() == INVALID_HANDLE_VALUE) {
  140. m_Enabled = FALSE;
  142. m_Started = FALSE;
  144. return;
  145. }
  147. if (m_Started) {
  149. return;
  151. }
  152. //
  153. // send the start ioctl
  154. //
  155. DWORD bytesReturned;
  156. BOOL result = 
  157. DeviceIoControl(theApp.hookDriver.handle(), 
  158. START_IP_HOOK,       // operation control code
  159. NULL,           // input data buffer
  160. 0,         // size of input data buffer
  161. NULL,          // output data buffer
  162. 0,        // size of output data buffer
  163. &bytesReturned,     // byte count
  164. NULL    // overlapped information
  165. );
  167. if (FALSE == result) {
  169. AfxErrorMessageBox(CString(_T("DeviceIoControl START_IP_HOOK")), GetLastError());
  171. return;
  172. }
  174. //
  175. // prime the pump with some buffers
  176. //
  177. if (FALSE == startSomeBuffers(4)) {
  178. //
  179. // ug, clean up the mess here
  180. //
  181. (void) DeviceIoControl(theApp.hookDriver.handle(), 
  182. STOP_IP_HOOK,       // operation control code
  183. NULL,           // input data buffer
  184. 0,         // size of input data buffer
  185. NULL,          // output data buffer
  186. 0,        // size of output data buffer
  187. &bytesReturned,     // byte count
  188. NULL    // overlapped information
  189. );
  190. } else {
  191. //
  192. // if that worked, then check and disable this menu item
  193. //
  194. m_Started = TRUE;
  195. }
  197. }
  199. void CMainFrame::OnStopHook() 
  200. {
  201. if (theApp.hookDriver.handle() == INVALID_HANDLE_VALUE) {
  203. m_Started = FALSE;
  205. m_Enabled = FALSE;
  207. return;
  208. }
  210. if (!m_Started) {
  212. return;
  214. }
  215. //
  216. // send the stop ioctl
  217. //
  218. DWORD bytesReturned;
  219. BOOL result = 
  220. DeviceIoControl(theApp.hookDriver.handle(), 
  221. STOP_IP_HOOK,       // operation control code
  222. NULL,           // input data buffer
  223. 0,         // size of input data buffer
  224. NULL,          // output data buffer
  225. 0,        // size of output data buffer
  226. &bytesReturned,     // byte count
  227. NULL    // overlapped information
  228. );
  230. if (FALSE == result) {
  232. AfxErrorMessageBox(CString(_T("DeviceIoControl STOP_IP_HOOK")), GetLastError());
  234. } else {
  236. //
  237. // if that worked then check and disable this menu item
  238. //
  239. m_Started = FALSE;
  240. //
  241. // wait for our worker thread to terminate
  242. //
  243. DWORD waitResult = WaitForSingleObject(workerHandle, 5000);
  244. if (waitResult != WAIT_OBJECT_0) {
  245. //
  246. // terminate the worker thread with prejudice
  247. //
  248. TerminateThread(workerHandle, 1);
  249. }
  250. CloseHandle(workerHandle);
  251. }
  253. }
  255. void CMainFrame::OnUpdateStartHook(CCmdUI* pCmdUI) 
  256. {
  257. pCmdUI->Enable(m_Enabled);
  258. pCmdUI->SetCheck(m_Started);
  260. }
  262. void CMainFrame::OnUpdateStopHook(CCmdUI* pCmdUI) 
  263. {
  264. pCmdUI->Enable(m_Enabled);
  266. if (m_Enabled) {
  268. pCmdUI->SetCheck(!m_Started);
  270. } else {
  272. pCmdUI->SetCheck(FALSE);
  274. }
  276. }
  280. IoContext::IoContext(UINT nbuffs)
  281. {
  282. if (nbuffs < 1) {
  284. AfxErrorMessageBox(CString(_T("nBuffers too small:")), nbuffs);
  286. ExitProcess(1);
  287. //
  288. // not reached
  289. //
  290. }
  292. nbuffers = nbuffs;
  293. //
  294. // create an event
  295. //
  296. event = CreateEvent(NULL, TRUE, FALSE, NULL);
  297. if (event == NULL) {
  299. DWORD error = GetLastError();
  301. AfxErrorMessageBox(CString(_T("CreateEvent:")), error);
  303. ExitProcess(error);
  304. //
  305. // not reached
  306. //
  307. }
  309. rawBuffer = NULL;
  310. buffer = NULL;
  312. }
  314. IoContext::~IoContext()
  315. {
  316. if (rawBuffer) {
  318. delete[] rawBuffer;
  319. }
  321. if (event) {
  323. CloseHandle(event);
  325. }
  326. }
  328. bool IoContext::init()
  329. {
  330. rawBuffer = new UCHAR[sizeof(IPHOOK_BUFFER) + (sizeof(IPHOOK_DATA) * (nbuffers -1))];
  332. if (rawBuffer == NULL) {
  334. AfxErrorMessageBox(CString(_T("nBuffers too small:")), nbuffers);
  336. return false;
  337. //
  338. // not reached
  339. //
  340. }
  342. buffer = (IPHOOK_BUFFER*) rawBuffer;
  343. overlapped.hEvent = event;
  344. buffer->entries=nbuffers;
  345. buffer->valid = 0;
  346. buffer->tag = IPHOOK_BUFFER_TAG;
  347. memset(&buffer->buffer[0], 0, sizeof(IPHOOK_DATA) * nbuffers);
  348. return true;
  349. }
  351. DWORD WINAPI workerStart(
  352.   LPVOID lpParameter   // thread data
  353. )
  354. {
  355. WIN_CONTEXT context  = *((WIN_CONTEXT *) lpParameter); // ignored for now
  357. //
  358. // until we get asked to stop,
  359. // produce numBufs, wait for completion or termination,
  360. // repeat as needed.
  361. //
  362. // we actually need to keep the buffers ordered, or else we
  363. // will have a re-ordering problem on the other side. The easiest
  364. // way to do that is to use only two buffers.
  365. //
  366. IoContext buffArray[2] = { 100, 100 };
  368. //
  369. // prime the pump
  370. //
  371. DWORD bytesReturned;
  373. while (*context.pStarted == TRUE) {
  375. for (UINT index = 0; index < 2; index++) {
  376. //
  377. // init allocates an io buffer and sets up the
  378. // contents of the buffer.
  379. //
  380. buffArray[index].init();
  382. BOOL result = 
  383. DeviceIoControl(theApp.hookDriver.handle(), 
  384. HOOK_THIS,       // operation control code
  385. NULL,           // input data buffer
  386. 0,         // size of input data buffer
  387. buffArray[index].IoBuffer(),          // output data buffer
  388. buffArray[index].IoSize(),        // size of output data buffer
  389. &bytesReturned,     // byte count
  390. buffArray[index].over()    // overlapped information
  391. );
  392. if (!result) {
  394. AfxErrorMessage(CString(_T("DeviceIoControl HOOK_THIS: ")), GetLastError());
  396. }
  397. }
  398. //
  399. // as each request completes, poat it to the widow thread
  400. //
  401. for (index = 0; index < 2; index++) {
  403. BOOL result = 
  404. GetOverlappedResult(theApp.hookDriver.handle(), 
  405. buffArray[index].over(),
  406. &bytesReturned,
  407. TRUE);
  409. if (!result) {
  411. AfxErrorMessage(CString(_T("GetOverlappedResult: ")), GetLastError());
  412. //
  413. // we have to free the buffer?
  414. //
  415. buffArray[index].deleteBuffer();
  418. } else {
  419. //
  420. // post this to the window side
  421. //
  422. buffArray[index].releaseBuffer();
  424. PostMessage(context.mainwindow, 
  425.         BUFFER_AVAILABLE_MSG, (UINT) buffArray[index].IoBuffer(), 0);
  427. }
  430. }
  433. }
  436. return 0;
  437. }
  439. BOOLEAN CMainFrame::startSomeBuffers(UINT numBufs)
  440. {
  441. //
  442. // this function spawns a worker thread whose job it is
  443. // to feed the driver with buffers and wait for those buffers
  444. // to return.
  445. //
  446. m_context.numBufs = 2;
  447. m_context.mainwindow = GetSafeHwnd();
  448. m_context.pStarted = &m_Started;
  449. ASSERT(m_context.mainwindow);
  451. workerHandle = CreateThread(NULL, 0, workerStart, (PVOID) &m_context, 0, &workerId);
  453. if (workerHandle == NULL) {
  455. AfxErrorMessage(CString(_T("CreateThread: ")), GetLastError());
  457. return FALSE;
  458. }
  460. return TRUE;
  462. }
  464. afx_msg LRESULT CMainFrame::OnBufferMessage(WPARAM wParam, LPARAM lParam)
  465. {
  466. //
  467. // just hand this to the view
  468. //
  469. CView* view = GetActiveView( );
  471. if (view) {
  473. view->PostMessage(BUFFER_AVAILABLE_MSG, wParam, lParam);
  474. }
  476. return 0;
  477. }
  478. ///////////////////////////////////////////////////////////////////////////////
  479. // 
  480. // Change History Log
  481. //
  482. // $Log: /iphook/usr/IpMonitor/MainFrm.cpp $
  483. // 
  484. // 3     1/27/00 10:35p Markr
  485. // Prepare to release!
  486. //
  487. ///////////////////////////////////////////////////////////////////////////////