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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
REGMON.C
资源名称：regmonsrc.zip　[点击查看]
上传用户：kevenhsn
上传日期：2007-01-03
资源大小：251k
文件大小：61k
源码类别：

系统编程

开发平台：

Visual C++

REGMON.C：源码内容
  1. /******************************************************************************
  2. *
  3. *       Regmon - Registry Monitor for Windows NT and Windows 9x
  4. *
  5. * Copyright (c) 1996 - 1998 Mark Russinovich and Bryce Cogswell
  6. *
  7. * See readme.txt for terms and conditions.
  8. *
  9. *     PROGRAM: Regmon.c
  10. *
  11. *     PURPOSE: Communicates with the RegMon driver to display 
  12. * registry activity information.
  13. *
  14. ******************************************************************************/
  15. #include <windows.h>   
  16. #include <windowsx.h>
  17. #include <tchar.h>
  18. #include <commctrl.h>  
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <winioctl.h>
  22. #include "resource.h"
  23. #include "ioctlcmd.h"
  24. #include "regmon.h"
  26. // this typedef, present in newer include files,
  27. // supports the building regmon on older systems
  28. typedef struct 
  29. {
  30.     DWORD cbSize;
  31.     DWORD dwMajorVersion;
  32.     DWORD dwMinorVersion;
  33.     DWORD dwBuildNumber;
  34.     DWORD dwPlatformID;
  35. } DLLVERSIONINFO_, *PDLLVERSIONINFO_;
  37. HRESULT (CALLBACK *pDllGetVersionProc)( PDLLVERSIONINFO_ pdvi );
  39. // delay for listview subitem tooltip
  40. #define BALLOONDELAY    10
  42. // toolbar height plus the borders
  43. #define TOOLBARHEIGHT 28
  45. // Number of columns in the listview
  46. #define NUMCOLUMNS 6
  48. // Variables/definitions for the driver that performs the actual monitoring.
  49. #define SYS_FILE _T("REGSYS.SYS")
  50. #define SYS_NAME _T("REGMON")
  52. #define VXD_FILE "\\.\REGVXD.VXD"
  53. #define VXD_NAME "REGVXD"
  55. static HANDLE SysHandle = INVALID_HANDLE_VALUE;
  57. // length in ms we wait for Regedit to update its display 
  58. #define REGEDITSLOWWAIT 750
  60. // version number for position settings
  61. #define POSVERSION 400
  63. // Position settings data structure 
  64. typedef struct {
  65. int posversion;
  66. int left;
  67. int top;
  68. int width;
  69. int height;
  70. DWORD column[NUMCOLUMNS];
  71. DWORD historydepth;
  72. BOOLEAN maximized;
  73. FILTER  filter;
  74. BOOLEAN ontop;
  75. } POSITION_SETTINGS;
  77. // The variable that holds the position settings
  78. POSITION_SETTINGS PositionInfo;
  80. // typedef for balloon popup
  81. typedef struct {
  82. CHAR itemText[1024];
  83. RECT itemPosition;
  84. } ITEM_CLICK, *PITEM_CLICK;
  86. // toolbar constants
  87. #define ID_TOOLBAR         1
  89. // defined for comtl32.dll version 4.7
  90. #define TOOLBAR_FLAT 0x800
  92. // button definitions
  94. // for installations that support flat style
  95. TBBUTTON tbButtons[] = {
  96. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  97. { 0, IDM_SAVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  98. { 8, 0, 0, TBSTYLE_BUTTON, 0L, 0},
  99. { 2, IDM_CAPTURE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  100. { 4, IDM_AUTOSCROLL, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  101. { 6, IDM_CLEAR, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  102. { 8, 0, 0, TBSTYLE_BUTTON, 0L, 0},
  103. { 5, IDM_FILTER, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  104. { 8, 0, 0, TBSTYLE_BUTTON, 0L, 0},
  105. { 7, IDM_FIND, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  106. { 9, IDM_JUMP, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  107. { 8, 0, 0, TBSTYLE_BUTTON, 0L, 0},
  108. };
  109. #define NUMBUTTONS 12
  111. // for older installations
  112. TBBUTTON tbButtonsOld[] = {
  113. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  114. { 0, IDM_SAVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  115. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  116. { 2, IDM_CAPTURE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  117. { 4, IDM_AUTOSCROLL, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  118. { 6, IDM_CLEAR, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  119. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  120. { 5, IDM_FILTER, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  121. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  122. { 7, IDM_FIND, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  123. { 9, IDM_JUMP, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  124. };  
  125. #define NUMBUTTONSOLD 11
  127. // Buffer into which driver can copy statistics
  128. char Stats[ MAX_STORE ];
  129. // Current fraction of buffer filled
  130. DWORD StatsLen;
  132. // Search string
  133. TCHAR FindString[256];
  134. FINDREPLACE FindTextInfo;
  135. DWORD FindFlags = FR_DOWN;
  136. BOOLEAN PrevMatch;
  137. TCHAR PrevMatchString[256];
  139. // Application instance handle
  140. HINSTANCE hInst;
  142. // For info saving
  143. TCHAR szFileName[256];
  144. BOOLEAN FileChosen = FALSE;
  146. // Windows NT or Windows 9x?
  147. BOOLEAN IsNT;
  149. // Misc globals
  150. HWND hWndMain;
  151. HWND hWndFind = NULL;
  152. UINT findMessageID;
  153. HWND hWndList;
  154. WNDPROC  ListViewWinMain;
  155. HWND hBalloon = NULL;
  156. BOOLEAN Capture = TRUE;
  157. BOOLEAN Autoscroll = TRUE;
  158. BOOLEAN BootLog = FALSE;
  159. BOOLEAN BootLogMenuUsed = FALSE;
  160. BOOLEAN Deleting = FALSE;
  161. BOOLEAN OnTop = FALSE;
  163. // Driver's registry key
  164. TCHAR DriverRegistryKey[] = _T("System\CurrentControlSet\Services\Regmon");
  166. // General buffer for storing temporary strings
  167. static TCHAR msgbuf[ 257 ];
  169. // Filter-related
  170. FILTER FilterDefinition;
  172. // listview size limiting
  173. DWORD MaxLines = 0;
  174. DWORD LastRow = 0;
  176. // General cursor manipulation
  177. HCURSOR  hSaveCursor;
  178. HCURSOR  hHourGlass;
  181. /******************************************************************************
  182. *
  183. * FUNCTION: RegeditJump
  184. *
  185. * PURPOSE: Opens Regedit and navigates the desired key
  186. *
  187. *****************************************************************************/
  188. void RegeditJump( HWND hWnd )
  189. {
  190. int currentItem;
  191. int pos;
  192. char * ch;
  193. HWND regeditHwnd, regeditMainHwnd;
  194. char compressPath[MAX_PATH];
  195. HKEY hKey;
  196. char *value = NULL;
  197. DWORD status;
  198. char RegPath[MAX_PATH];
  199. DEVMODE devMode;
  201. // Get the color depth, which can effect the speed that Regedit
  202. // responds to keyboard commands
  203. devMode.dmSize = sizeof(DEVMODE);
  204. EnumDisplaySettings( NULL, ENUM_CURRENT_SETTINGS, &devMode );
  206. // See if we can get a Registry path out of the listview
  207. // find the item with the focus
  208. currentItem = ListView_GetNextItem( hWndList, -1, LVNI_SELECTED );
  210. if( currentItem == -1 ) {
  212. MessageBox( hWnd, _T("No item selected."),
  213. _T("Regmon"), MB_OK|MB_ICONWARNING );
  214. return;
  215. }
  216. memset( compressPath, 0, MAX_PATH );
  217. ListView_GetItemText( hWndList, currentItem, 3, compressPath, MAX_PATH );
  219. // If the key is a handle reference, tell the user we're sorry
  220. if( compressPath[0] == '0' ) {
  222. MessageBox( hWnd, _T("The full name of the selected key or value is not available."),
  223. _T("Regmon"), MB_OK|MB_ICONWARNING );
  224. return;
  225. }
  227. // We need to uncompress abbreviations
  228. if( !strncmp( compressPath, "HKLM", strlen("HKLM"))) {
  230. sprintf( RegPath, "\HKEY_LOCAL_MACHINE%s", &compressPath[strlen("HKLM")] );
  231. status = RegOpenKey( HKEY_LOCAL_MACHINE, &compressPath[strlen("HKLM")+1], &hKey );
  233. } else if( !strncmp( compressPath, "HKCU", strlen("HKCU"))) {
  235. sprintf( RegPath, "\HKEY_CURRENT_USER%s", &compressPath[strlen("HKCU")] );
  236. status = RegOpenKey( HKEY_CURRENT_USER, &compressPath[strlen("HKCU")+1], &hKey );
  238. } else if( !strncmp( compressPath, "HKCC", strlen("HKCC"))) {
  240. sprintf( RegPath, "\HKEY_CURRENT_CONFIG%s", &compressPath[strlen("HKCC")] );
  241. status = RegOpenKey( HKEY_CURRENT_CONFIG, &compressPath[strlen("HKCC")+1], &hKey );
  243. } else if( !strncmp( compressPath, "HKCR", strlen("HKCR"))) {
  245. sprintf( RegPath, "\HKEY_CLASSES_ROOT%s", &compressPath[strlen("HKCR")] );
  246. status = RegOpenKey( HKEY_CLASSES_ROOT, &compressPath[strlen("HKCR")+1], &hKey );
  248. } else if( !strncmp( compressPath, "HKU", strlen("HKU"))) {
  250. sprintf( RegPath, "\HKEY_USERS%s", &compressPath[strlen("HKU")] );
  251. status = RegOpenKey( HKEY_USERS, &compressPath[strlen("HKU")+1], &hKey );
  253. } else {
  255. strcpy( RegPath, compressPath );
  256. status = FALSE;
  257. }
  259. // Is it a value or a key?
  260. if( status == ERROR_SUCCESS ) {
  262. RegCloseKey( hKey );
  263. strcat( RegPath, "\" );
  265. } else {
  267. value = strrchr( RegPath, '\')+1;
  268. *strrchr( RegPath, '\' ) = 0;
  269. }
  271. // Open RegEdit
  272. regeditMainHwnd = FindWindow( "RegEdit_RegEdit", NULL );
  273. if ( regeditMainHwnd == NULL )  {
  274. SHELLEXECUTEINFO info;
  275. memset( &info, 0, sizeof info );
  276. info.cbSize = sizeof info;
  277. info.fMask = SEE_MASK_NOCLOSEPROCESS; 
  278. info.lpVerb = "open"; 
  279. info.lpFile = "regedit.exe"; 
  280. info.nShow = SW_SHOWNORMAL; 
  281. ShellExecuteEx( &info );
  282. WaitForInputIdle( info.hProcess, INFINITE );
  283. regeditMainHwnd = FindWindow( "RegEdit_RegEdit", NULL );
  284. } 
  286. if( regeditMainHwnd == NULL ) {
  288. MessageBox( hWnd, _T("Regmon was unable to launch Regedit."),
  289. _T("Regmon"), MB_OK|MB_ICONERROR );
  290. return;
  291. }
  292.     ShowWindow( regeditMainHwnd, SW_SHOW );
  293. SetForegroundWindow( regeditMainHwnd );
  295. // Get treeview
  296. regeditHwnd = FindWindowEx( regeditMainHwnd, NULL, "SysTreeView32", NULL );
  297. SetForegroundWindow( regeditHwnd );
  298. SetFocus( regeditHwnd );
  300. // Close it up
  301. for ( pos = 0; pos < 30; ++pos )  {
  302. UINT vk = VK_LEFT;
  303. SendMessage( regeditHwnd, WM_KEYDOWN, vk, 0 );
  304. }
  306. // wait for slow displays - 
  307. // Regedit takes a while to open keys with lots of subkeys
  308. // when running at high color depths 
  309. if( devMode.dmBitsPerPel > 8 ) Sleep(REGEDITSLOWWAIT); 
  311. // Open path
  312. for ( ch = RegPath; *ch; ++ch )  {
  313. if ( *ch == '\' )  {
  314. UINT vk = VK_RIGHT;
  315. SendMessage( regeditHwnd, WM_KEYDOWN, vk, 0 );
  317. // wait for slow displays - 
  318. // Regedit takes a while to open keys with lots of subkeys
  319. // when running at high color depths 
  320. if( devMode.dmBitsPerPel > 8 ) Sleep(REGEDITSLOWWAIT); 
  322. } else {
  323. UINT vk = toupper(*ch);
  325. SendMessage( regeditHwnd, WM_CHAR, vk, 0 );
  326. }
  327. }
  329. // If its a value select the value
  330. if( value ) {
  331. UINT vk = VK_HOME;
  333. regeditHwnd = FindWindowEx( regeditMainHwnd, NULL, "SysListView32", NULL );
  334. SetForegroundWindow( regeditHwnd );
  335. SetFocus( regeditHwnd );
  336. Sleep(1000); // have to wait for Regedit to update listview
  337. SendMessage( regeditHwnd, WM_KEYDOWN, vk, 0 );
  339. for ( ch = value; *ch; ++ch )  {
  340. UINT vk = toupper(*ch);
  342. SendMessage( regeditHwnd, WM_CHAR, vk, 0 );
  343. }
  344. }
  346. SetForegroundWindow( regeditMainHwnd );
  347. SetFocus( regeditMainHwnd );
  348. }
  350. /******************************************************************************
  351. *
  352. * FUNCTION: Abort:
  353. *
  354. * PURPOSE: Handles emergency exit conditions.
  355. *
  356. *****************************************************************************/
  357. LONG Abort( HWND hWnd, TCHAR * Msg )
  358. {
  359. LPVOID lpMsgBuf;
  360. TCHAR errmsg[256];
  361. DWORD error = GetLastError();
  362.  
  363. FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  364. NULL, GetLastError(), 
  365. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  366. (LPTSTR) &lpMsgBuf, 0, NULL );
  367. if( IsNT ) UnloadDeviceDriver( SYS_NAME );
  368. sprintf(errmsg, _T("%s: %s"), Msg, lpMsgBuf );
  369. if( error == ERROR_INVALID_HANDLE && IsNT ) 
  370. wsprintf(errmsg, _T("%snMake sure that you are an administrator and that ")
  371. _T("Regmon is located on a local drive."), errmsg  );
  372. MessageBox( hWnd, errmsg, _T("Regmon"), MB_OK|MB_ICONERROR );
  373. PostQuitMessage( 1 );
  374. LocalFree( lpMsgBuf );
  375. return -1;
  376. }
  378. /******************************************************************************
  379. *
  380. * FUNCTION: BalloonDialog
  381. *
  382. * PURPOSE: Dialog function for home-brewed balloon help.
  383. *
  384. ******************************************************************************/
  385. LONG APIENTRY BalloonDialog( HWND hDlg, UINT message, UINT wParam, LONG lParam )
  386. {
  387. static ITEM_CLICK ctx;
  388. static RECT rect;
  389. static HFONT hfont;
  390. LPCREATESTRUCT lpcs;
  391. HDC hdc;
  392. POINTS pts;
  393. POINT pt;
  394. DWORD newclicktime;
  395.     NONCLIENTMETRICS ncm;
  396. static POINT lastclickpt = {0,0};
  397. static DWORD lastclicktime = 0;
  399. switch (message) {
  400. case WM_CREATE:
  402. lpcs = (void *)lParam;
  403. ctx = *(PITEM_CLICK) lpcs->lpCreateParams;
  404. hdc = GetDC( hDlg );
  406. // Get font
  407. if ( hfont == NULL )  {
  409. memset(&ncm, 0, sizeof(ncm));
  410. ncm.cbSize = sizeof(ncm);
  411. SystemParametersInfo( SPI_GETNONCLIENTMETRICS, 
  412. 0, &ncm, 0);
  413.   hfont = CreateFontIndirect( &ncm.lfMessageFont ); 
  414. } 
  416. // is the app the focus?
  417. if( !GetFocus()) return -1;
  419. // Compute size of required rectangle
  420. rect.left = 0;
  421. rect.top = 0;
  422. rect.right = lpcs->cx;
  423. rect.bottom = lpcs->cy;
  424. SelectObject( hdc, hfont );
  425. DrawText( hdc, ctx.itemText, -1, &rect, 
  426. DT_NOCLIP|DT_LEFT|DT_NOPREFIX|DT_CALCRECT );
  428. // if the bounding rectangle of the subitem is big enough to display
  429. // the text then don't pop the balloon
  430. if( ctx.itemPosition.right > rect.right + 11 ) {
  432. return -1;
  433. }
  435. // Move and resize window
  436. if( ctx.itemPosition.left - 5 + rect.right + 10 >
  437.  GetSystemMetrics(SM_CXFULLSCREEN) ) {
  439.  ctx.itemPosition.left = GetSystemMetrics(SM_CXFULLSCREEN) -
  440. (rect.right+10);
  441. }
  442. MoveWindow( hDlg, 
  443. ctx.itemPosition.left+3, ctx.itemPosition.top, 
  444. rect.right + 6, 
  445. rect.bottom + 1,
  446. TRUE );
  448. // Adjust rectangle so text is centered
  449. rect.left += 2;
  450. rect.right += 2;
  451. rect.top -= 1; 
  452. rect.bottom += 0;
  454. // make it so this window doesn't get the focus
  455. ShowWindow( hDlg, SW_SHOWNOACTIVATE );
  456. break;
  458. case WM_LBUTTONDBLCLK:
  459. case WM_RBUTTONDBLCLK:
  460. case WM_MBUTTONDBLCLK:
  461. case WM_LBUTTONDOWN:
  462. case WM_RBUTTONDOWN:
  463. case WM_MBUTTONDOWN:
  464. case WM_LBUTTONUP:
  465. case WM_RBUTTONUP:
  466. case WM_MBUTTONUP:
  468. pts = MAKEPOINTS( lParam );
  469. pt.x = (LONG) pts.x;
  470. pt.y = (LONG) pts.y;
  471. ClientToScreen( hDlg, &pt );
  473. // pass this through to the listview
  474. if( ScreenToClient( hWndList, &pt )) {
  476. if( message == WM_LBUTTONDOWN ) {
  478. // see if its a double click
  479. newclicktime = GetTickCount();
  480. if( pt.x == lastclickpt.x && pt.y == lastclickpt.y && 
  481. newclicktime - lastclicktime < 300 ) {
  483. message = WM_LBUTTONDBLCLK;
  484. }
  485. lastclicktime = newclicktime;
  486. lastclickpt = pt;
  487. }
  489. PostMessage( hWndList, message, wParam, (SHORT) pt.y<<16 | (SHORT) pt.x );
  490. }
  491. break;
  493. case WM_PAINT:
  494. hdc = GetDC( hDlg );
  496. // Set colors
  497. SetTextColor( hdc, 0x00000000 );
  498. SetBkMode( hdc, TRANSPARENT );
  499. SelectObject( hdc, hfont );
  500. DrawText( hdc, ctx.itemText, -1, &rect, 
  501. DT_NOCLIP|DT_LEFT|DT_NOPREFIX|DT_WORDBREAK );
  502. break;
  504. case WM_DESTROY:
  505. hBalloon = NULL;
  506. break;
  508. case WM_CLOSE:
  509. DestroyWindow( hDlg );
  510. break;
  511. }
  513.     return DefWindowProc( hDlg, message, wParam, lParam );
  514. }
  517. /******************************************************************************
  518. *
  519. * FUNCTION: FindInListview:
  520. *
  521. * PURPOSE: Searches for a string in the listview. Note: its okay if
  522. * items are being added to the list view or the list view
  523. * is cleared while this search is in progress - the effect
  524. * is harmless.
  525. *
  526. *****************************************************************************/
  527. BOOLEAN FindInListview(HWND hWnd, LPFINDREPLACE FindInfo )
  528. {
  529. int currentItem;
  530. DWORD i;
  531. int subitem, numItems;
  532. TCHAR fieldtext[256];
  533. BOOLEAN match = FALSE;
  534. TCHAR errmsg[256];
  535. BOOLEAN goUp;
  537. // get the search direction
  538. goUp = ((FindInfo->Flags & FR_DOWN) == FR_DOWN);
  540. // initialize stuff
  541. if( !(numItems = ListView_GetItemCount( hWndList ))) {
  543. MessageBox( hWnd, _T("No items to search"), _T("Regmon"), 
  544. MB_OK|MB_ICONWARNING );
  545. SetForegroundWindow( hWndFind );
  546. return FALSE;
  547. }
  549. // find the item with the focus
  550. currentItem = ListView_GetNextItem( hWndList, 0, LVNI_SELECTED );
  552. // if no current item, start at the top or the bottom
  553. if( currentItem == -1 ) {
  554. if( goUp )
  555. currentItem = 0;
  556. else {
  557. if( PrevMatch ) {
  558. sprintf(errmsg, _T("Cannot find string "%s""), FindInfo->lpstrFindWhat );
  559. MessageBox( hWnd, errmsg, _T("Regmon"), MB_OK|MB_ICONWARNING );
  560. SetForegroundWindow( hWndFind );
  561. return FALSE;
  562. }
  563. currentItem = numItems;
  564. }
  565. }
  567. // if we're continuing a search, start with the next item
  568. if( PrevMatch && !strcmp( FindString, PrevMatchString ) ) {
  569. if( goUp ) currentItem++;
  570. else currentItem--;
  572. if( (!goUp && currentItem < 0) ||
  573. (goUp && currentItem >= numItems )) {
  575. sprintf(errmsg, _T("Cannot find string "%s""), FindInfo->lpstrFindWhat );
  576. MessageBox( hWnd, errmsg, _T("Regmon"), MB_OK|MB_ICONWARNING );
  577. SetForegroundWindow( hWndFind );
  578. return FALSE;
  579. }
  580. }
  582. // loop through each item looking for the string
  583. while( 1 ) {
  585. // get the item text
  586. for( subitem = 0; subitem < NUMCOLUMNS; subitem++ ) {
  587. fieldtext[0] = 0;
  588. ListView_GetItemText( hWndList, currentItem, subitem, fieldtext, MAX_PATH );
  590. // make sure enought string for a match
  591. if( strlen( fieldtext ) < strlen( FindInfo->lpstrFindWhat ))
  592. continue;
  594. // do a scan all the way through for the substring
  595. if( FindInfo->Flags & FR_WHOLEWORD ) {
  597. i = 0;
  598. while( fieldtext[i] ) {
  599. while( fieldtext[i] && fieldtext[i] != ' ' ) i++;
  600. if( FindInfo->Flags & FR_MATCHCASE ) 
  601. match = !strcmp( fieldtext, FindInfo->lpstrFindWhat );
  602. else
  603. match = !stricmp( fieldtext, FindInfo->lpstrFindWhat );
  604. if( match) break;
  605. i++;
  606. }
  607. } else {
  608. for( i = 0; i < strlen( fieldtext ) - strlen(FindInfo->lpstrFindWhat)+1; i++ ) {
  609. if( FindInfo->Flags & FR_MATCHCASE ) 
  610. match = !strncmp( &fieldtext[i], FindInfo->lpstrFindWhat, 
  611. strlen(FindInfo->lpstrFindWhat) );
  612. else
  613. match = !strnicmp( &fieldtext[i], FindInfo->lpstrFindWhat,
  614. strlen(FindInfo->lpstrFindWhat) );
  615. if( match ) break;
  616. }
  617. }
  619. if( match ) {
  621. strcpy( PrevMatchString, FindInfo->lpstrFindWhat );
  622. PrevMatch = TRUE;
  623. ListView_SetItemState( hWndList, currentItem, 
  624. LVIS_SELECTED|LVIS_FOCUSED,
  625. LVIS_SELECTED|LVIS_FOCUSED );
  626. ListView_EnsureVisible( hWndList, currentItem, FALSE ); 
  627. SetFocus( hWndList );
  628. return TRUE;
  629. }
  630. }
  631. currentItem = currentItem + (goUp ? 1:-1);
  632. if( !currentItem || currentItem == numItems+1 ) {
  633. // end of the road
  634. break;
  635. }
  636. }
  637. sprintf(errmsg, _T("Cannot find string "%s""), FindInfo->lpstrFindWhat );
  638. MessageBox( hWnd, errmsg, _T("Regmon"), MB_OK|MB_ICONWARNING );
  639. SetForegroundWindow( hWndFind );
  640. return FALSE;
  641. }
  644. /******************************************************************************
  645. *
  646. * FUNCTION: PopFindDialog:
  647. *
  648. * PURPOSE: Calls the find message dialog box.
  649. *
  650. *****************************************************************************/
  651. void PopFindDialog(HWND hWnd)
  652. {
  653. strcpy( FindString, PrevMatchString );
  654.     FindTextInfo.lStructSize = sizeof( FindTextInfo );
  655.     FindTextInfo.hwndOwner = hWnd;
  656.     FindTextInfo.hInstance = (HANDLE)hInst;
  657.     FindTextInfo.lpstrFindWhat = FindString;
  658.     FindTextInfo.lpstrReplaceWith = NULL;
  659.     FindTextInfo.wFindWhatLen = sizeof(FindString);
  660.     FindTextInfo.wReplaceWithLen = 0;
  661.     FindTextInfo.lCustData = 0;
  662.     FindTextInfo.Flags =  FindFlags;
  663.     FindTextInfo.lpfnHook = (LPFRHOOKPROC)(FARPROC)NULL;
  664.     FindTextInfo.lpTemplateName = NULL;
  666.     if ((hWndFind = FindText(&FindTextInfo)) == NULL)
  667. MessageBox( hWnd, _T("Unable to create Find dialog"), _T("Regmon"), MB_OK|MB_ICONERROR );      
  668. }
  671. /******************************************************************************
  672. *
  673. * FUNCTION: Get_Position_Settings
  674. *
  675. * PURPOSE: Reads the Registry to get the last-set window position.
  676. *
  677. ******************************************************************************/
  678. VOID Get_Position_Settings()
  679. {
  680. HKEY hKey;
  681. DWORD ParamSize;
  682. POSITION_SETTINGS regPositionInfo;
  684. // Fist, set the default settings
  685. PositionInfo.top = CW_USEDEFAULT;
  686. PositionInfo.left = CW_USEDEFAULT;
  687. PositionInfo.width = CW_USEDEFAULT;
  688. PositionInfo.height = CW_USEDEFAULT;
  689. PositionInfo.maximized = FALSE;
  690. PositionInfo.ontop = FALSE;
  692. // set the default listview widths
  693. PositionInfo.column[0] = 35;
  694. PositionInfo.column[1] = 90;
  695. PositionInfo.column[2] = 130;
  696. PositionInfo.column[3] = 200;
  697. PositionInfo.column[4] = 70;
  698. PositionInfo.column[5] = 150;
  700. // Initialize the filter
  701. sprintf( PositionInfo.filter.processfilter, "*" );
  702. strcpy( PositionInfo.filter.processexclude, "" );
  703. sprintf( PositionInfo.filter.pathfilter,    "*" );
  704. sprintf( PositionInfo.filter.excludefilter, "" );
  705. PositionInfo.filter.logsuccess = TRUE;
  706. PositionInfo.filter.logerror   = TRUE;
  707. PositionInfo.filter.logreads   = TRUE;
  708. PositionInfo.filter.logwrites  = TRUE;
  710. // set the default history depth (infinite)
  711. PositionInfo.historydepth = 0;
  713. // first, get the last-entered params from the registry
  714. RegCreateKey(HKEY_CURRENT_USER, 
  715. _T("Software\Systems Internals\Regmon"),
  716. &hKey );
  718. // get the params and ignore errors
  719. ParamSize = sizeof( PositionInfo );
  720. RegQueryValueEx( hKey,_T("Settings"), NULL, NULL, (LPBYTE) &regPositionInfo,
  721. &ParamSize );
  722. RegCloseKey( hKey );
  724. // only use the registry settings if the version matches
  725. if( regPositionInfo.posversion == POSVERSION ) PositionInfo = regPositionInfo;
  727. // extract the history depth
  728. MaxLines = PositionInfo.historydepth;
  729. OnTop = PositionInfo.ontop;
  731. // initialize filter
  732. FilterDefinition    = PositionInfo.filter;
  733. }
  736. /******************************************************************************
  737. *
  738. * FUNCTION: Save_Position_Settings
  739. *
  740. * PURPOSE: Saves the current window settings to the Registry.
  741. *
  742. ******************************************************************************/
  743. VOID Save_Position_Settings( HWND hWnd )
  744. {
  745. RECT rc;
  746. int i;
  747. HKEY hKey;
  749. // set version #
  750. PositionInfo.posversion = POSVERSION;
  752. // get the position of the main window
  753. GetWindowRect( hWnd, &rc );
  754. if( !IsIconic( hWnd )) {
  756. PositionInfo.left = rc.left;
  757. PositionInfo.top = rc.top;
  758. PositionInfo.width = rc.right - rc.left;
  759. PositionInfo.height = rc.bottom - rc.top;
  760. } 
  761. PositionInfo.maximized = IsZoomed( hWnd );
  762. PositionInfo.ontop = OnTop;
  764. // get the widths of the listview columns
  765. for( i = 0; i < NUMCOLUMNS; i++ ) {
  766. PositionInfo.column[i] = ListView_GetColumnWidth( hWndList, i );
  767. }
  769. // get the history depth
  770. PositionInfo.historydepth = MaxLines;
  772. // save filters
  773. PositionInfo.filter = FilterDefinition;
  775. // save connection info to registry
  776. RegOpenKey(HKEY_CURRENT_USER, 
  777. _T("Software\Systems Internals\Regmon"),
  778. &hKey );
  779. RegSetValueEx( hKey, _T("Settings"), 0, REG_BINARY, (LPBYTE) &PositionInfo,
  780. sizeof( PositionInfo ) );
  781. RegCloseKey( hKey );
  782. }
  785. /******************************************************************************
  786. *
  787. * FUNCTION: Split
  788. *
  789. * PURPOSE: Split a delimited line into components
  790. *
  791. ******************************************************************************/
  792. int Split( char * line, char delimiter, char * items[] )
  793. {
  794. int cnt = 0;
  796. for (;;)  {
  797. // Add prefix to list of components
  798. items[cnt++] = line;
  800. // Check for more components
  801. line = strchr( line, delimiter );
  802. if ( line == NULL )
  803. return cnt;
  805. // Terminate previous component and move to next
  806. *line++ = '';
  807. }
  808. }
  811. /******************************************************************************
  812. *
  813. * FUNCTION: ListAppend
  814. *
  815. * PURPOSE: Add a new line to List window
  816. *
  817. ******************************************************************************/
  818. BOOL List_Append( HWND hWndList, DWORD seq, char * line )
  819. {
  820. LV_ITEM lvI; // list view item structure
  821. int row;
  822. char * items[20];
  823. int itemcnt = 0;
  825. // Split line into columns
  826. itemcnt = Split( line, 't', items );
  827. if ( itemcnt == 0 )
  828. return FALSE;
  830. // Determine row number for request
  831. if ( *items[0] )  {
  832. // Its a new request.  Put at end.
  833. row = 0x7FFFFFFF;
  834. } else {
  835. // Its a status.  Locate its associated request.
  836. lvI.mask = LVIF_PARAM;
  837. lvI.iSubItem = 0;
  838. for ( row = ListView_GetItemCount(hWndList) - 1; row >= 0; --row )  {
  839. lvI.iItem = row;
  840. if ( ListView_GetItem( hWndList, &lvI )  &&  (DWORD)lvI.lParam == seq )
  841. break;
  842. }
  843. if ( row == -1 )
  844. // No request associated with status.
  845. return FALSE;
  846. }
  848. // Sequence number if a new item
  849. if ( *items[0] )  {
  850. wsprintf( msgbuf, _T("%d"), seq );
  851. lvI.mask = LVIF_TEXT | LVIF_PARAM;
  852. lvI.iItem = row;
  853. lvI.iSubItem = 0;
  854. lvI.pszText = msgbuf;
  855. lvI.cchTextMax = lstrlen( lvI.pszText ) + 1;
  856. lvI.lParam = seq;
  857. row = ListView_InsertItem( hWndList, &lvI );
  858. if ( row == -1 )  {
  859. wsprintf( msgbuf, _T("Error adding item %d to list view"), seq );
  860. MessageBox( hWndList, msgbuf, _T("Regmon Error"), MB_OK );
  861. return FALSE;
  862. }
  863.         LastRow = row;
  864. }
  866. // Process name
  867. if ( itemcnt>0 && *items[0] ) {
  868. OemToChar( items[0], msgbuf );
  869. ListView_SetItemText( hWndList, row, 1, msgbuf );
  870. }
  872. // Request type
  873. if ( itemcnt>1 && *items[1] )  {
  874. OemToChar( items[1], msgbuf );
  875. ListView_SetItemText( hWndList, row, 2, msgbuf );
  876. }
  878. // Path
  879. if ( itemcnt>2 && *items[2] )  {
  880. OemToChar( items[2], msgbuf );
  881. ListView_SetItemText( hWndList, row, 3, msgbuf );
  882. }
  884. // Result
  885. if ( itemcnt>3 && *items[3] )  {
  886. OemToChar( items[3], msgbuf );
  887. ListView_SetItemText( hWndList, row, 4, msgbuf );
  888. }
  890. // Additional
  891. if ( itemcnt>4 && *items[4] )  {
  892. OemToChar( items[4], msgbuf );
  893. ListView_SetItemText( hWndList, row, 5, msgbuf );
  894. }
  896. return TRUE;
  897. }
  900. /******************************************************************************
  901. *
  902. * FUNCTION: UpdateStatistics
  903. *
  904. * PURPOSE: Clear the statistics window and refill it with the current 
  905. * contents of the statistics buffer.  Does not refresh the 
  906. * buffer from the device driver.
  907. *
  908. ******************************************************************************/
  909. void UpdateStatistics( HWND hWnd, HWND hWndList, BOOL Clear )
  910. {
  911. PENTRY ptr;
  912. BOOLEAN itemsAdded = FALSE;
  913. int totitems, i;
  915. // Just return if nothing to do
  916. if ( !Clear  &&  StatsLen < sizeof(int)+2 )
  917. return;
  919. if( !IsNT ) {
  921. hSaveCursor = SetCursor(hHourGlass);
  922. SendMessage(hWndList, WM_SETREDRAW, FALSE, 0);
  923. }
  925. // Start with empty list
  926. if ( Clear ) {
  928. if( IsNT ) {
  930. ListView_DeleteAllItems( hWndList );
  931. } else {
  933. totitems = ListView_GetItemCount( hWndList );
  934. Deleting = TRUE;
  935. for(i = 0; i < totitems; i++)
  936. ListView_DeleteItem( hWndList, 0 );
  937. Deleting = FALSE;
  938. }
  939. LastRow = 0;
  940. }
  942. // Add all List items from Stats[] data
  943. for ( ptr = (void *)Stats; (char *)ptr < min(Stats+StatsLen,Stats + sizeof (Stats)); )  {
  944.   // Add to list
  945. ULONG len = strlen(ptr->text);
  946.         if( IsNT ) {
  948. len += 4; len &= 0xFFFFFFFC; // +1 for null-terminator +3 for 32bit alignment
  949. }
  951. itemsAdded |= List_Append( hWndList, ptr->seq, ptr->text );
  953. if( IsNT ) ptr = (void *)(ptr->text + len);
  954. else       ptr = (void *)(ptr->text + len + 1);
  955. }
  957. // Empty the buffer
  958. StatsLen = 0;
  960. // only do this if we added items
  961. if( itemsAdded ) {
  963. // limit number of lines saved
  964. if (MaxLines) {
  965. SendMessage(hWndList, WM_SETREDRAW, FALSE, 0);
  966. while ( LastRow > MaxLines ) {
  967. ListView_DeleteItem ( hWndList, 0 );
  968. LastRow--;
  969. }
  970. SendMessage(hWndList, WM_SETREDRAW, TRUE, 0);
  971. }
  973. // Scroll so newly added items are visible
  974. if ( Autoscroll ) {
  975. if( hBalloon ) DestroyWindow( hBalloon );
  976. ListView_EnsureVisible( hWndList, ListView_GetItemCount(hWndList)-1, FALSE ); 
  977. }
  978. }
  980. if( !IsNT ) {
  981. SetCursor( hSaveCursor );
  982. SendMessage(hWndList, WM_SETREDRAW, TRUE, 0);
  983. InvalidateRect( hWndList, NULL, FALSE );
  984. }
  985. }
  988. /****************************************************************************
  989. * 
  990. *    FUNCTION: ListViewSubclass(HWND,UINT,WPARAM)
  991. *
  992. *    PURPOSE:  Subclasses the listview so that we can do tooltips
  993. *
  994. ****************************************************************************/
  995. LRESULT CALLBACK ListViewSubclass(HWND hWnd, UINT uMsg, WPARAM wParam,
  996.         LPARAM lParam)
  997. {
  998. ITEM_CLICK itemClick;
  999. LVHITTESTINFO hitItem;
  1000. static initTrack = FALSE;
  1001. POINT           hitPoint, topleftPoint, bottomrightPoint;
  1002. RECT listRect;
  1003. static POINTS  mousePosition;
  1005. if( !initTrack ) {
  1007. SetTimer( hWnd, 2, BALLOONDELAY, NULL );
  1008. initTrack = TRUE;
  1009. }
  1011.     switch (uMsg) {
  1013. case WM_LBUTTONDBLCLK:
  1014. case WM_RBUTTONDBLCLK:
  1015. case WM_MBUTTONDBLCLK:
  1016. case WM_LBUTTONUP:
  1017. case WM_RBUTTONUP:
  1018. case WM_MBUTTONUP:
  1019. case WM_LBUTTONDOWN:
  1020. case WM_MBUTTONDOWN:
  1021. case WM_MOUSEMOVE:
  1022. // delete any existing balloon
  1023. if( hBalloon ) DestroyWindow( hBalloon );
  1025. // save mouse position and reset the timer
  1026. mousePosition = MAKEPOINTS( lParam );
  1027. SetTimer( hWnd, 2, BALLOONDELAY, NULL );
  1028. break;
  1030. case WM_KEYDOWN:
  1031. case WM_VSCROLL:
  1032. case WM_HSCROLL:
  1033. if( hBalloon ) DestroyWindow( hBalloon );
  1034. break;
  1036. case WM_RBUTTONDOWN:
  1037. mousePosition = MAKEPOINTS( lParam );
  1038. SetTimer( hWnd, 2, BALLOONDELAY, NULL );
  1039. // fall-through
  1041. case WM_TIMER:
  1043. // are we currently in the listview?
  1044. GetCursorPos( &hitPoint );
  1045. GetClientRect( hWnd, &listRect );
  1046. topleftPoint.x = listRect.left;
  1047. topleftPoint.y = listRect.top;
  1048. ClientToScreen( hWnd, &topleftPoint );
  1049. bottomrightPoint.x = listRect.right;
  1050. bottomrightPoint.y = listRect.bottom;
  1051. ClientToScreen( hWnd, &bottomrightPoint );
  1052. if( hitPoint.x < topleftPoint.x ||
  1053. hitPoint.x > bottomrightPoint.x ||
  1054. hitPoint.y < topleftPoint.y ||
  1055. hitPoint.y > bottomrightPoint.y ||
  1056. (hWndFind && GetFocus() != hWndList) ) {
  1058. // delete any existing balloon
  1059. if( hBalloon ) DestroyWindow( hBalloon );
  1060. break;
  1061. }
  1063. hitItem.pt.x = mousePosition.x;
  1064. hitItem.pt.y =  mousePosition.y;
  1065. if( ListView_SubItemHitTest( hWndList, &hitItem ) != -1 ) {
  1067. itemClick.itemText[0] = 0;
  1068. ListView_GetItemText( hWndList, hitItem.iItem,
  1069. hitItem.iSubItem, itemClick.itemText, 1024 );
  1071. // delete any existing balloon
  1072. if( hBalloon ) DestroyWindow( hBalloon );
  1074. if( strlen( itemClick.itemText ) ) {
  1076. if( hitItem.iSubItem ) {
  1078. ListView_GetSubItemRect( hWndList, hitItem.iItem, hitItem.iSubItem,
  1079. LVIR_BOUNDS, &itemClick.itemPosition);
  1081. itemClick.itemPosition.bottom -= itemClick.itemPosition.top;
  1082. itemClick.itemPosition.right  -= itemClick.itemPosition.left;
  1084. } else {
  1086. ListView_GetSubItemRect( hWndList, hitItem.iItem, 1,
  1087. LVIR_BOUNDS, &itemClick.itemPosition);
  1089. itemClick.itemPosition.bottom -= itemClick.itemPosition.top;
  1090. itemClick.itemPosition.right  = itemClick.itemPosition.left;
  1091. itemClick.itemPosition.left   = 0;
  1092. }
  1094. hitPoint.y = itemClick.itemPosition.top;
  1095. hitPoint.x = itemClick.itemPosition.left;
  1097. ClientToScreen( hWnd, &hitPoint );
  1099. itemClick.itemPosition.left = hitPoint.x;
  1100. itemClick.itemPosition.top  = hitPoint.y;
  1102. // pop-up a balloon (tool-tip like window)
  1103. hBalloon = CreateWindowEx( 0, _T("BALLOON"), 
  1104. _T("balloon"), 
  1105. WS_POPUP|WS_BORDER,
  1106. 100, 100,
  1107. 200, 200,
  1108. hWndMain, NULL, hInst, 
  1109. &itemClick );
  1110. if( hBalloon) SetFocus( hWnd );
  1111. }
  1112. }
  1113. break;
  1114.     }
  1116. // pass-through to real listview handler
  1117.     return CallWindowProc(ListViewWinMain, hWnd, uMsg, wParam, 
  1118.             lParam);
  1119. }
  1122. /****************************************************************************
  1123. * 
  1124. *    FUNCTION: CreateListView(HWND)
  1125. *
  1126. *    PURPOSE:  Creates the statistics list view window and initializes it
  1127. *
  1128. ****************************************************************************/
  1129. HWND CreateList( HWND hWndParent )                                     
  1130. {
  1131. HWND hWndList;        // handle to list view window
  1132. RECT rc;             // rectangle for setting size of window
  1133. LV_COLUMN lvC; // list view column structure
  1134. DWORD j;
  1135. static struct {
  1136. TCHAR * Label; // title of column
  1137. DWORD Width; // width of column in pixels
  1138. DWORD Fmt;
  1139. } column[] = {
  1140. { "#" , 35 },
  1141. { "Process" , 90 },
  1142. { "Request" , 90 },
  1143. { "Path" , 225 },
  1144. { "Result" , 90 },
  1145. { "Other" , 150 },
  1146. };
  1148. // Ensure that the common control DLL is loaded.
  1149. InitCommonControls();
  1151. // Set the column widths according to the user-settings
  1152. for( j = 0; j < NUMCOLUMNS; j++ ) {
  1153. column[j].Width = PositionInfo.column[j];
  1154. }
  1156. // Get the size and position of the parent window.
  1157. GetClientRect( hWndParent, &rc );
  1159. // Create the list view window
  1160. hWndList = CreateWindowEx( /* WS_EX_CLIENTEDGE */ 0L, WC_LISTVIEW, _T(""), 
  1161. WS_VISIBLE | WS_CHILD | WS_BORDER | LVS_REPORT |
  1162. LVS_SINGLESEL,
  1163. 0, TOOLBARHEIGHT, rc.right - rc.left, rc.bottom - rc.top - TOOLBARHEIGHT,
  1164. hWndParent, (HMENU)ID_LIST, hInst, NULL );
  1165. if ( hWndList == NULL )
  1166. return NULL;
  1168. // Initialize columns
  1169. lvC.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  1170. lvC.fmt = LVCFMT_LEFT; // left-align column
  1172. // Add the columns.
  1173. for ( j = 0; j < sizeof column/sizeof column[0]; ++j )  {
  1174. lvC.iSubItem = j;
  1175. lvC.cx = column[j].Width;
  1176.   lvC.pszText = column[j].Label;
  1177. if ( ListView_InsertColumn( hWndList, j, &lvC ) == -1 )
  1178. return NULL;
  1179. }
  1181. // set full-row selection
  1182. SendMessage( hWndList, LVM_SETEXTENDEDLISTVIEWSTYLE,
  1183. LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT );
  1185. // sub-class
  1186. ListViewWinMain = (WNDPROC) SetWindowLong(hWndList, 
  1187.                                               GWL_WNDPROC, 
  1188.                                               (DWORD)ListViewSubclass); 
  1189. return hWndList;
  1190. }
  1193. /****************************************************************************
  1194. * 
  1195. *    FUNCTION: SaveFile()
  1196. *
  1197. *    PURPOSE:  Lets the user go select a file.
  1198. *
  1199. ****************************************************************************/
  1200. void SaveFile( HWND hWnd, HWND ListBox, BOOLEAN SaveAs )
  1201. {
  1202. OPENFILENAME SaveFileName;
  1203. char szFile[256] = "", fieldtext[256], output[1024];
  1204. FILE *hFile;
  1205. int numitems;
  1206. int row, subitem;
  1208. if( SaveAs || !FileChosen ) {
  1209. SaveFileName.lStructSize       = sizeof (SaveFileName);
  1210. SaveFileName.hwndOwner         = hWnd;
  1211. SaveFileName.hInstance         = (HANDLE) hInst;
  1212. SaveFileName.lpstrFilter       = "Reg Data (*.RGD)*.RGDAll (*.*)*.*";
  1213. SaveFileName.lpstrCustomFilter = (LPTSTR)NULL;
  1214. SaveFileName.nMaxCustFilter    = 0L;
  1215. SaveFileName.nFilterIndex      = 1L;
  1216. SaveFileName.lpstrFile         = szFile;
  1217. SaveFileName.nMaxFile          = 256;
  1218. SaveFileName.lpstrFileTitle    = NULL;
  1219. SaveFileName.nMaxFileTitle     = 0;
  1220. SaveFileName.lpstrInitialDir   = NULL;
  1221. SaveFileName.lpstrTitle        = "Save File Info...";
  1222. SaveFileName.nFileOffset       = 0;
  1223. SaveFileName.nFileExtension    = 0;
  1224. SaveFileName.lpstrDefExt       = "*.rgd";
  1225. SaveFileName.lpfnHook    = NULL;
  1226.   SaveFileName.Flags = OFN_LONGNAMES|OFN_HIDEREADONLY;
  1228. if( !GetSaveFileName( &SaveFileName )) 
  1229. return;
  1230. } else 
  1231. // open previous szFile
  1232. strcpy( szFile, szFileName );
  1234. // open the file
  1235. hFile = fopen( szFile, "w" );
  1236. if( !hFile ) {
  1237. MessageBox( NULL, "Create File Failed.",
  1238. "Save Error", MB_OK|MB_ICONSTOP );
  1239. return;
  1240. }
  1241. // post hourglass icon
  1242. SetCapture(hWnd);
  1243. hSaveCursor = SetCursor(hHourGlass);
  1245. numitems = ListView_GetItemCount(ListBox);
  1246. for ( row = 0; row < numitems; row++ )  {
  1247. output[0] = 0;
  1248. for( subitem = 0; subitem < 6; subitem++ ) {
  1249. fieldtext[0] = 0;
  1250. ListView_GetItemText( ListBox, row, subitem, fieldtext, 256 );
  1251. strcat( output, fieldtext );
  1252. strcat( output, "t" );
  1253. }
  1254. fprintf( hFile, "%sn", output );
  1255. }
  1256. fclose( hFile );
  1257. strcpy( szFileName, szFile );
  1258. FileChosen = TRUE;
  1259. SetCursor( hSaveCursor );
  1260. ReleaseCapture(); 
  1261. }
  1265. /****************************************************************************
  1266. *
  1267. * FUNCTION: FilterProc
  1268. *
  1269. * PURPOSE: Processes messages for "Filter" dialog box
  1270. *
  1271. ****************************************************************************/
  1272. BOOL APIENTRY FilterProc( HWND hDlg, UINT message, UINT wParam, LONG lParam )
  1273. {
  1274. int nb;
  1275. FILTER upcaseFilter;
  1276. DWORD newMaxLines;
  1277. char history[64];
  1279. switch ( message )  {
  1280. case WM_INITDIALOG:
  1282. // initialize the controls to reflect the current filter
  1283. SetDlgItemText( hDlg, IDC_PROCFILTER, FilterDefinition.processfilter );
  1284. SetDlgItemText( hDlg, IDC_PROCEXCLUDE, FilterDefinition.processexclude );
  1285. SetDlgItemText( hDlg, IDC_PATHFILTER, FilterDefinition.pathfilter );
  1286. SetDlgItemText( hDlg, IDC_EXCLUDEFILTER, FilterDefinition.excludefilter );
  1287. CheckDlgButton( hDlg, IDC_SUCCESS, FilterDefinition.logsuccess );
  1288. CheckDlgButton( hDlg, IDC_ERROR,   FilterDefinition.logerror );
  1289. CheckDlgButton( hDlg, IDC_LOGREADS, FilterDefinition.logreads );
  1290. CheckDlgButton( hDlg, IDC_LOGWRITES,   FilterDefinition.logwrites );
  1291. sprintf( history, "%d", MaxLines );
  1292. SetDlgItemText( hDlg, IDC_HISTORY, history );
  1293. return TRUE;
  1295. case WM_COMMAND:              
  1296. if ( LOWORD( wParam ) == IDOK )  {
  1298. // make sure that max lines is legal
  1299. GetDlgItemTextA( hDlg, IDC_HISTORY, history, 64 );
  1300. if( !sscanf( history, "%d", &newMaxLines )) {
  1302. MessageBox( NULL, _T("Invalid History Depth."),
  1303. _T("Filter Error"), MB_OK|MB_ICONWARNING );
  1304. return TRUE;
  1305. } 
  1306. MaxLines = newMaxLines;
  1308. // read the values that were set
  1309. GetDlgItemText( hDlg, IDC_PROCFILTER, FilterDefinition.processfilter, MAXFILTERLEN );
  1310. GetDlgItemText( hDlg, IDC_PROCEXCLUDE, FilterDefinition.processexclude, MAXFILTERLEN );
  1311. GetDlgItemText( hDlg, IDC_PATHFILTER, FilterDefinition.pathfilter, MAXFILTERLEN );
  1312. GetDlgItemText( hDlg, IDC_EXCLUDEFILTER, FilterDefinition.excludefilter, MAXFILTERLEN );
  1313. FilterDefinition.logsuccess = IsDlgButtonChecked( hDlg, IDC_SUCCESS );
  1314. FilterDefinition.logerror   = IsDlgButtonChecked( hDlg, IDC_ERROR );
  1315. FilterDefinition.logreads = IsDlgButtonChecked( hDlg, IDC_LOGREADS );
  1316. FilterDefinition.logwrites   = IsDlgButtonChecked( hDlg, IDC_LOGWRITES );
  1318. // make an upcase version for the driver
  1319. upcaseFilter = FilterDefinition;
  1320. _strupr(upcaseFilter.processfilter);
  1321. _strupr(upcaseFilter.processexclude);
  1322. _strupr(upcaseFilter.pathfilter);
  1323. _strupr(upcaseFilter.excludefilter);
  1324.  
  1325. // tell the driver the new filter
  1326. if ( ! DeviceIoControl( SysHandle, REGMON_setfilter,
  1327. &upcaseFilter, sizeof(FILTER), NULL, 
  1328. 0, &nb, NULL ) )
  1329. {
  1330. Abort( hDlg, _T("Couldn't access device driver") );
  1331. return TRUE;
  1332. }
  1334. EndDialog( hDlg, TRUE );
  1335. return TRUE;
  1337. } else if( LOWORD( wParam ) == IDCANCEL ) {
  1339. EndDialog( hDlg, TRUE );
  1341. } else if( LOWORD( wParam ) == IDRESET ) {
  1343. // reset filter to default of none
  1344. sprintf( FilterDefinition.processfilter, "*" );
  1345. sprintf( FilterDefinition.processexclude, "" );
  1346. sprintf( FilterDefinition.pathfilter, "*" );
  1347. sprintf( FilterDefinition.excludefilter, "");
  1348. FilterDefinition.logsuccess = TRUE;
  1349. FilterDefinition.logerror = TRUE;
  1350. FilterDefinition.logreads = TRUE;
  1351. FilterDefinition.logwrites = TRUE;
  1352. MaxLines = 0;
  1353.  
  1354. // initialize the controls to reflect the current filter
  1355. SetDlgItemText( hDlg, IDC_PROCFILTER, FilterDefinition.processfilter );
  1356. SetDlgItemText( hDlg, IDC_PROCEXCLUDE, FilterDefinition.processexclude );
  1357. SetDlgItemText( hDlg, IDC_PATHFILTER, FilterDefinition.pathfilter );
  1358. SetDlgItemText( hDlg, IDC_EXCLUDEFILTER, FilterDefinition.excludefilter );
  1359. CheckDlgButton( hDlg, IDC_SUCCESS, FilterDefinition.logsuccess );
  1360. CheckDlgButton( hDlg, IDC_ERROR,   FilterDefinition.logerror );
  1361. CheckDlgButton( hDlg, IDC_LOGREADS, FilterDefinition.logreads );
  1362. CheckDlgButton( hDlg, IDC_LOGWRITES,   FilterDefinition.logwrites );
  1363. SetDlgItemText( hDlg, IDC_HISTORY, "0" );
  1364. }
  1365. break;
  1367. case WM_CLOSE:
  1368. EndDialog( hDlg, TRUE );
  1369. return TRUE;
  1370. }
  1371. return FALSE;   
  1372. }
  1375. /****************************************************************************
  1376. *
  1377. * FUNCTION: About
  1378. *
  1379. * PURPOSE: Processes messages for "About" dialog box
  1380. *
  1381. ****************************************************************************/
  1382. BOOL APIENTRY About( HWND hDlg, UINT message, UINT wParam, LONG lParam )
  1383. {
  1384. switch ( message )  {
  1385.    case WM_INITDIALOG:
  1386.   return TRUE;
  1388.    case WM_COMMAND:              
  1389.   if ( LOWORD( wParam ) == IDOK )  {
  1390.   EndDialog( hDlg, TRUE );
  1391.   return TRUE;
  1392.   }
  1393.   break;
  1395.    case WM_CLOSE:
  1396.   EndDialog( hDlg, TRUE );
  1397.   return TRUE;
  1398. }
  1399. return FALSE;   
  1400. }
  1403. /******************************************************************************
  1404. *
  1405. * FUNCTION: GetDLLVersion
  1406. *
  1407. * PURPOSE: Gets the version number of the specified DLL.
  1408. *
  1409. ******************************************************************************/
  1410. HRESULT GetDLLVersion( PCHAR DllName, LPDWORD pdwMajor, LPDWORD pdwMinor)
  1411. {
  1412. HINSTANCE hDll;
  1413. HRESULT hr = S_OK;
  1414. DLLVERSIONINFO_ dvi;
  1416. *pdwMajor = 0;
  1417. *pdwMinor = 0;
  1419. //Load the DLL.
  1420. hDll = LoadLibrary(DllName);
  1422. if( hDll ) {
  1424.    pDllGetVersionProc = (PVOID)GetProcAddress(hDll, _T("DllGetVersion"));
  1426.    if(pDllGetVersionProc) {
  1427.   
  1428.   ZeroMemory(&dvi, sizeof(dvi));
  1429.   dvi.cbSize = sizeof(dvi);
  1431.   hr = (*pDllGetVersionProc)(&dvi);
  1432.   
  1433.   if(SUCCEEDED(hr)) {
  1435.  *pdwMajor = dvi.dwMajorVersion;
  1436.  *pdwMinor = dvi.dwMinorVersion;
  1437.   }
  1438.     } else {
  1440.   // If GetProcAddress failed, the DLL is a version previous to the one 
  1441.   // shipped with IE 3.x.
  1442.   *pdwMajor = 4;
  1443.   *pdwMinor = 0;
  1444.       }
  1445.    
  1446.   FreeLibrary(hDll);
  1447.   return hr;
  1448. }
  1450. return E_FAIL;
  1451. }
  1454. /****************************************************************************
  1455. *
  1456. *    FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
  1457. *
  1458. *    PURPOSE:  Processes messages for the statistics window.
  1459. *
  1460. ****************************************************************************/
  1461. LONG APIENTRY MainWndProc( HWND hWnd, UINT message, UINT wParam, LONG lParam) 
  1462. {
  1463. DWORD nb, versionNumber;
  1464. DWORD length, type, tag, driverStart;
  1465. TCHAR Path[ MAX_PATH ];
  1466. HKEY hDriverKey;
  1467. static TCHAR group[] = "System Bus Extender";
  1468. static TCHAR driverPath[ MAX_PATH ];
  1469. TCHAR systemRoot[ MAX_PATH ];
  1470. static TCHAR logFile[ MAX_PATH ];
  1471. static HWND hWndToolbar;
  1472. LPTOOLTIPTEXT lpToolTipText;
  1473. static TCHAR szBuf[128];
  1474. LPFINDREPLACE findMessageInfo;
  1475. DWORD majorver, minorver;
  1476. TCHAR *File;
  1477. WIN32_FIND_DATA findData;
  1478. HANDLE findHandle;
  1479. DWORD startTime;
  1480. POINT hitPoint;
  1481. RECT listRect;
  1482. HDC hDC;
  1483. PAINTSTRUCT Paint;
  1484. MENUITEMINFO bootMenuItem;
  1486. switch ( message ) {
  1488. case WM_CREATE:
  1490. // get hourglass icon ready
  1491. hHourGlass = LoadCursor( NULL, IDC_WAIT );
  1493. // post hourglass icon
  1494. SetCapture(hWnd);
  1495. hSaveCursor = SetCursor(hHourGlass);
  1497. // Create the toolbar control - use modern style if available.
  1498. GetDLLVersion( "comctl32.dll", &majorver, &minorver );
  1499. if( majorver > 4 || (majorver == 4 && minorver >= 70) ) {
  1500. hWndToolbar = CreateToolbarEx( 
  1501. hWnd, TOOLBAR_FLAT | WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS,  
  1502. ID_TOOLBAR, 9, hInst, IDB_TOOLBAR, (LPCTBBUTTON)&tbButtons,
  1503. NUMBUTTONS, 16,16,16,15, sizeof(TBBUTTON)); 
  1504. } else {
  1505. hWndToolbar = CreateToolbarEx( 
  1506. hWnd, WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS,  
  1507. ID_TOOLBAR, 9, hInst, IDB_TOOLBAR, (LPCTBBUTTON)&tbButtonsOld,
  1508. NUMBUTTONSOLD, 16,16,16,15, sizeof(TBBUTTON)); 
  1509. }
  1510. if (hWndToolbar == NULL )
  1511. MessageBox (NULL, _T("Toolbar not created!"), NULL, MB_OK );
  1513. // Create the ListBox within the main window
  1514. hWndList = CreateList( hWnd );
  1515. if ( hWndList == NULL )
  1516. MessageBox( NULL, _T("List not created!"), NULL, MB_OK );
  1518.     // open the handle to the device
  1519. if( IsNT ) {
  1521. // Add the log boot menu item
  1522. bootMenuItem.cbSize = sizeof( bootMenuItem );
  1523. bootMenuItem.fMask = MIIM_TYPE;
  1524. bootMenuItem.fType = MFT_SEPARATOR;
  1525. InsertMenuItem( GetSubMenu( GetMenu(hWnd), 1 ), 
  1526. GetMenuItemCount( GetSubMenu( GetMenu(hWnd), 1 )),
  1527. TRUE, &bootMenuItem );
  1528. bootMenuItem.fMask = MIIM_TYPE|MIIM_ID;
  1529. bootMenuItem.fType = MFT_STRING;
  1530. bootMenuItem.wID = IDM_BOOTLOG;
  1531. bootMenuItem.dwTypeData = (PCHAR) "Log &Boot";
  1532. InsertMenuItem( GetSubMenu( GetMenu(hWnd), 1 ), 
  1533. GetMenuItemCount( GetSubMenu( GetMenu(hWnd), 1 )),
  1534. TRUE, &bootMenuItem );
  1536. GetCurrentDirectory( sizeof Path, Path );
  1537. sprintf( Path+lstrlen(Path), _T("\%s"), SYS_FILE );
  1539. findHandle = FindFirstFile( Path, &findData );
  1540. if( findHandle == INVALID_HANDLE_VALUE ) {
  1542. if( !SearchPath( NULL, SYS_FILE, NULL, sizeof(Path), Path, &File ) ) {
  1544. sprintf( msgbuf, _T("%s was not found."), SYS_FILE );
  1545. return Abort( hWnd, msgbuf );
  1546. }
  1548. } else FindClose( findHandle );
  1550. // read driver start type to see if boot-logging is enabled
  1551. driverStart = SERVICE_DEMAND_START;
  1552. if( RegOpenKey( HKEY_LOCAL_MACHINE, DriverRegistryKey, &hDriverKey ) == 
  1553. ERROR_SUCCESS ) {
  1555. length = sizeof( driverStart );
  1556. RegQueryValueEx( hDriverKey, "Start", NULL, &type,
  1557. (PBYTE) &driverStart, &length);
  1558. RegCloseKey( hDriverKey );
  1559. } 
  1560. BootLog = (driverStart != SERVICE_DEMAND_START);
  1562. // check boot logging menu item if boot start
  1563. CheckMenuItem( GetMenu(hWnd), IDM_BOOTLOG,
  1564. MF_BYCOMMAND|(BootLog?MF_CHECKED:MF_UNCHECKED) ); 
  1566. // copy the driver to <winnt>system32drivers so that we can do
  1567. // boot-time monitoring with the flip of a bit
  1568. // get the system root
  1569. if( !GetEnvironmentVariable( "SYSTEMROOT", systemRoot, sizeof(systemRoot))) {
  1571. strcpy( msgbuf, _T("Could not resolve SYSTEMROOT environment variable") );
  1572. return Abort( hWnd, msgbuf );
  1573. }
  1574. sprintf( logFile, _T("%s\REGMON.LOG"), systemRoot );
  1575. sprintf( driverPath, _T("%s\system32\drivers\%s"), 
  1576. systemRoot, SYS_FILE );
  1577. if( !CopyFile( Path, driverPath, FALSE )) {
  1579. sprintf( msgbuf, _T("Unable to copy %s to %snn")
  1580. _T("Make sure that regsys.sys is in the current directory."), 
  1581. SYS_NAME, driverPath );
  1582. return Abort( hWnd, msgbuf );
  1583. }
  1585. if ( ! LoadDeviceDriver( SYS_NAME, driverPath, &SysHandle ) )  {
  1587. sprintf( msgbuf, _T("Opening %s (%s): error %d"), SYS_NAME, Path,
  1588. GetLastError( ) );
  1589. return Abort( hWnd, msgbuf );
  1590. }
  1592. // Correct driver version?
  1593. if ( ! DeviceIoControl( SysHandle, REGMON_version,
  1594. NULL, 0, &versionNumber, sizeof(DWORD), &nb, NULL ) ||
  1595. versionNumber != REGMONVERSION )
  1596. {
  1597. MessageBox( hWnd, _T("Regmon located a driver with the wrong version.n")
  1598. _T("nIf you just installed a new version you must reboot before you are")
  1599. _T("able to use it."), _T("Regmon"), MB_ICONERROR);
  1600. return -1;
  1601. }
  1603. } else {
  1605. // Win9x
  1606. SysHandle = CreateFile( VXD_FILE, 0, 0, NULL,
  1607. 0, FILE_FLAG_OVERLAPPED|
  1608. FILE_FLAG_DELETE_ON_CLOSE,
  1609. NULL );
  1610. if ( SysHandle == INVALID_HANDLE_VALUE )  {
  1611. wsprintf( msgbuf, "%s is not loaded properly.", VXD_NAME );
  1612. Abort( hWnd, msgbuf );
  1613. return FALSE;
  1614. }
  1615. }
  1617. // Have driver zero information
  1618. if ( ! DeviceIoControl( SysHandle, REGMON_zerostats,
  1619. NULL, 0, NULL, 0, &nb, NULL ) )
  1620. {
  1621. return Abort( hWnd, _T("Couldn't access device driver") );
  1622. }
  1624. // Give the user to change initial filter
  1625. if( strcmp(FilterDefinition.processfilter, "*") ||
  1626. strcmp(FilterDefinition.processexclude, "") ||
  1627. strcmp(FilterDefinition.pathfilter, "*")    ||
  1628. strcmp(FilterDefinition.excludefilter, "")  ||
  1629. !FilterDefinition.logsuccess ||
  1630. !FilterDefinition.logerror   ||
  1631. !FilterDefinition.logreads   ||
  1632. !FilterDefinition.logwrites ) {
  1634. DialogBox( hInst, _T("InitFilter"), hWnd, (DLGPROC) FilterProc );
  1636. } else {
  1638. // tell the driver the initial filter
  1639. if ( ! DeviceIoControl( SysHandle, REGMON_setfilter,
  1640. &FilterDefinition, sizeof(FILTER), NULL, 
  1641. 0, &nb, NULL ) )
  1642. {
  1643. return Abort( hWnd, _T("Couldn't access device driver") );
  1644. }
  1645. }
  1647. // Start up timer to periodically update screen
  1648. SetTimer( hWnd, 1, 500/*ms*/, NULL );
  1650. // Have driver turn on hooks
  1651. if ( ! DeviceIoControl( SysHandle, REGMON_hook,
  1652. NULL, 0, NULL, 0, &nb, NULL ) )
  1653. {
  1654. return Abort( hWnd, _T("Couldn't access device driver") );
  1655. }
  1657. // Initialization done
  1658. SetCursor( hSaveCursor );
  1659. ReleaseCapture();
  1660. return FALSE;
  1662. case WM_NOTIFY:
  1663. // Make sure its intended for us
  1664. if ( wParam == ID_LIST )  {
  1665. NM_LISTVIEW * pNm = (NM_LISTVIEW *)lParam;
  1666. switch ( pNm->hdr.code )  {
  1668.         case LVN_BEGINLABELEDIT:
  1669. // Don't allow editing of information
  1670. return TRUE;
  1672. case NM_DBLCLK:
  1673. case NM_RETURN:
  1675. // open the specified key in Regedit, if we can
  1676. RegeditJump( hWnd );
  1677. return TRUE;
  1678. }
  1679. } else {
  1681. switch (((LPNMHDR) lParam)->code) 
  1682. {
  1683. case TTN_NEEDTEXT:    
  1684. // Display the ToolTip text.
  1685. lpToolTipText = (LPTOOLTIPTEXT)lParam;
  1686.      LoadString (hInst, lpToolTipText->hdr.idFrom, szBuf, sizeof(szBuf));
  1687.      lpToolTipText->lpszText = szBuf;
  1688. break;
  1690. default:
  1691. return FALSE;
  1692. }
  1693. }
  1694. return FALSE;
  1696. case WM_COMMAND:
  1698. switch ( LOWORD( wParam ) )  {
  1700. // stats related commands to send to driver
  1701. case IDM_CLEAR:
  1702. // Have driver zero information
  1703. if ( ! DeviceIoControl( SysHandle, REGMON_zerostats,
  1704. NULL, 0, NULL, 0, &nb, NULL ) )
  1705. {
  1706. Abort( hWnd, _T("Couldn't access device driver") );
  1707. return TRUE;
  1708. }
  1709. // Update statistics windows
  1710. UpdateStatistics( hWnd, hWndList, TRUE );
  1711. return FALSE;
  1713. case IDM_HELP:
  1714. WinHelp(hWnd, _T("regmon.hlp"), HELP_CONTENTS, 0L);
  1715. return 0;
  1717. case IDM_FIND:
  1718. // search the listview
  1719. if( !hWndFind ) {
  1720. PrevMatch = FALSE;
  1721. PopFindDialog( hWnd );
  1722. } else if( PrevMatch ) {
  1724. // treat this like a find-next
  1725. SetCapture(hWndFind);
  1726. hSaveCursor = SetCursor(hHourGlass);
  1727. EnableWindow( hWndFind, FALSE );
  1728. if (FindInListview( hWnd, &FindTextInfo ) ) {
  1729. Autoscroll = FALSE;
  1730. CheckMenuItem( GetMenu(hWnd), IDM_AUTOSCROLL,
  1731. MF_BYCOMMAND|MF_UNCHECKED ); 
  1732. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_AUTOSCROLL, 3 );
  1733. }
  1734. EnableWindow( hWndFind, TRUE );
  1735. SetCursor( hSaveCursor );
  1736. ReleaseCapture(); 
  1737. }
  1738. return 0;
  1740. case IDM_CAPTURE:
  1741. // Read statistics from driver
  1742. Capture = !Capture;
  1743. CheckMenuItem( GetMenu(hWnd), IDM_CAPTURE,
  1744. MF_BYCOMMAND|(Capture?MF_CHECKED:MF_UNCHECKED) );
  1746. // Have driver turn on hooks
  1747. if ( ! DeviceIoControl( SysHandle, Capture ? REGMON_hook : 
  1748. REGMON_unhook,
  1749. NULL, 0, NULL, 0, &nb, NULL ) )
  1750. {
  1751. Abort( hWnd, _T("Couldn't access device driver") );
  1752. return TRUE;
  1753. }
  1754. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_CAPTURE, (Capture?2:1) );
  1755. InvalidateRect( hWndToolbar, NULL, TRUE );
  1756. return FALSE;
  1758. case IDM_AUTOSCROLL:
  1759. Autoscroll = !Autoscroll;
  1760. CheckMenuItem( GetMenu(hWnd), IDM_AUTOSCROLL,
  1761. MF_BYCOMMAND|(Autoscroll?MF_CHECKED:MF_UNCHECKED) ); 
  1762. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_AUTOSCROLL, (Autoscroll?4:3) );
  1763. InvalidateRect( hWndToolbar, NULL, TRUE );
  1764. return FALSE;
  1766. case IDM_BOOTLOG:
  1767. BootLog = !BootLog;
  1768. CheckMenuItem( GetMenu(hWnd), IDM_BOOTLOG,
  1769. MF_BYCOMMAND|(BootLog?MF_CHECKED:MF_UNCHECKED) ); 
  1770. if( BootLog ) {
  1772. sprintf( msgbuf, 
  1773. _T("Regmon has been configured to log Registry activity to %s during the next boot"),
  1774. logFile );
  1775. MessageBox( hWnd, msgbuf, _T("Regmon"), MB_OK|MB_ICONINFORMATION);
  1776. }
  1777. BootLogMenuUsed = TRUE;
  1778. return FALSE;
  1780. case IDM_EXIT:
  1781. // Close ourself
  1782. SendMessage( hWnd, WM_CLOSE, 0, 0 );
  1783. return FALSE;
  1785. case IDM_FILTER:
  1786. DialogBox( hInst, _T("Filter"), hWnd, (DLGPROC) FilterProc );
  1787. return FALSE;
  1789. case IDM_ONTOP:
  1790. OnTop = !OnTop;
  1791. if( OnTop ) SetWindowPos( hWnd, HWND_TOPMOST, 0, 0, 0, 0, 
  1792. SWP_NOMOVE|SWP_NOSIZE );
  1793. else  SetWindowPos( hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, 
  1794. SWP_NOMOVE|SWP_NOSIZE );
  1795. CheckMenuItem( GetMenu(hWnd), IDM_ONTOP,
  1796. MF_BYCOMMAND|(OnTop?MF_CHECKED:MF_UNCHECKED) );
  1797. return 0;
  1799. case IDM_JUMP:
  1801. // open the specified key in Regedit, if we can
  1802. RegeditJump( hWnd );
  1803. return FALSE;
  1805. case IDM_ABOUT:
  1806. // Show the names of the authors
  1807. DialogBox( hInst, _T("AboutBox"), hWnd, (DLGPROC)About );
  1808. return FALSE;
  1810. case IDM_SAVE:
  1811. SaveFile( hWnd, hWndList, FALSE );
  1812. return FALSE;
  1814. case IDM_SAVEAS:
  1815. SaveFile( hWnd, hWndList, TRUE );
  1816. return FALSE;
  1818. default:
  1819. // Default behavior
  1820. return DefWindowProc( hWnd, message, wParam, lParam );
  1821. }
  1822. break;
  1824. case WM_TIMER:
  1825. // Time to query the device driver for more data
  1826. if ( Capture )  {
  1828. // don't process for more than a second without pausing
  1829. startTime = GetTickCount();
  1830. for (;;)  {
  1832. // Have driver fill Stats buffer with information
  1833. if ( ! DeviceIoControl( SysHandle, REGMON_getstats,
  1834. NULL, 0, &Stats, sizeof Stats,
  1835. &StatsLen, NULL ) )
  1836. {
  1837. Abort( hWnd, _T("Couldn't access device driver") );
  1838. return TRUE;
  1839. }
  1840. if ( StatsLen == 0 )
  1841. break;
  1843. // Update statistics windows
  1844. UpdateStatistics( hWnd, hWndList, FALSE );
  1846. if( GetTickCount() - startTime > 1000 ) break;
  1847. }
  1848. }
  1850. // delete balloon if necessary
  1851. if( hBalloon ) {
  1852. GetCursorPos( &hitPoint );
  1853. GetWindowRect( hWndList, &listRect );
  1854. if( hitPoint.x < listRect.left ||
  1855. hitPoint.x > listRect.right ||
  1856. hitPoint.y < listRect.top ||
  1857. hitPoint.y > listRect.bottom ) {
  1859. DestroyWindow( hBalloon );
  1860. }
  1861. }
  1862. return FALSE;
  1864. case WM_SIZE:
  1865. // Move or resize the List
  1866. MoveWindow( hWndToolbar, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE );
  1867.             MoveWindow( hWndList, 0, TOOLBARHEIGHT, LOWORD(lParam), HIWORD(lParam)-TOOLBARHEIGHT, TRUE );
  1868. if( hBalloon ) DestroyWindow( hBalloon );
  1869. return FALSE;
  1871. case WM_MOVE:
  1872. case WM_MOUSEMOVE:
  1873. if( hBalloon ) DestroyWindow( hBalloon );
  1874. return FALSE;
  1876. case WM_CLOSE:
  1878. // Have driver unhook if necessary
  1879. if( Capture ) {
  1880. if ( ! DeviceIoControl( SysHandle, REGMON_unhook,
  1881. NULL, 0, NULL, 0, &nb, NULL ) )
  1882. {
  1883. Abort( hWnd, _T("Couldn't access device driver") );
  1884. return TRUE;
  1885. }
  1886. }
  1888. KillTimer( hWnd, 1 );
  1889. CloseHandle( SysHandle );
  1890. #if _DEBUG
  1891. if ( IsNT &&  !UnloadDeviceDriver( SYS_NAME ) )  {
  1892. wsprintf( msgbuf, _T("Error unloading "%s""), SYS_NAME );
  1893. MessageBox( hWnd, msgbuf, _T("Regmon"), MB_OK );
  1894. }
  1895. #endif
  1896. // Make sure the user knows boot logging will take place
  1897. if( IsNT ) {
  1899. if( !BootLogMenuUsed && BootLog ) {
  1901. sprintf( msgbuf, 
  1902. _T("Regmon is configured to log Registry activity to %s during the next boot"),
  1903. logFile );
  1905. MessageBox( hWnd, msgbuf, _T("Regmon"), MB_ICONINFORMATION);
  1906. }
  1908. // if boot logging isn't enabled, delete the driver from 
  1909. // the drivers directory
  1910. if( !BootLog ) {
  1912. if( RegCreateKey( HKEY_LOCAL_MACHINE, DriverRegistryKey, &hDriverKey ) == 
  1913. ERROR_SUCCESS ) {
  1915. driverStart = SERVICE_DEMAND_START;
  1916. RegSetValueEx( hDriverKey, _T("Start"), 0, REG_DWORD, 
  1917. (PBYTE) &driverStart, sizeof(driverStart));
  1918. RegDeleteValue( hDriverKey, _T("Group"));
  1919. RegDeleteValue( hDriverKey, _T("Tag"));
  1920. DeleteFile( driverPath );
  1921. }
  1923. } else {
  1925. // boot logging on - configure the regmon service key.
  1926. if( RegCreateKey( HKEY_LOCAL_MACHINE, DriverRegistryKey, &hDriverKey ) == 
  1927. ERROR_SUCCESS ) {
  1929. // the driver is already in the winntsystem32drivers directory
  1930. driverStart = SERVICE_BOOT_START;
  1931. RegDeleteValue( hDriverKey, _T("DeleteFlag" ));
  1932. RegSetValueEx( hDriverKey, _T("Start"), 0, REG_DWORD, 
  1933. (PBYTE) &driverStart, sizeof(driverStart));
  1934. RegSetValueEx( hDriverKey, "Group", 0, REG_SZ, group, sizeof( group ));
  1935. tag = 1;
  1936. RegSetValueEx( hDriverKey, "Tag", 0, REG_DWORD, 
  1937. (PBYTE) &tag, sizeof(tag));
  1938. RegSetValueEx( hDriverKey, "Type", 0, REG_DWORD,
  1939. (PBYTE) &tag, sizeof(tag));
  1940. sprintf( Path, _T("System32\Drivers\%s"),
  1941. SYS_FILE );
  1942. RegSetValueEx( hDriverKey, _T("ImagePath"), 0, REG_EXPAND_SZ,
  1943. Path, strlen(Path));
  1944. RegCloseKey( hDriverKey );
  1946. } else {
  1948. Abort( hWnd, _T("Regmon could not configure boot logging"));
  1949. }
  1950. }
  1951. if( hDriverKey != INVALID_HANDLE_VALUE ) RegCloseKey( hDriverKey );
  1952. }
  1954. Save_Position_Settings( hWnd );
  1955. return DefWindowProc( hWnd, message, wParam, lParam );
  1957. case WM_SETFOCUS:
  1958. SetFocus( hWndList );
  1959. break;
  1961. case WM_DESTROY:
  1962. PostQuitMessage(0);
  1963. return FALSE;
  1965. case WM_PAINT:
  1966. if( !IsNT && Deleting ) {
  1967. hDC = BeginPaint( hWnd, &Paint );
  1968. EndPaint( hWnd, &Paint );
  1969. return TRUE;
  1970. }
  1971. return DefWindowProc( hWnd, message, wParam, lParam );
  1973. default:
  1974. // is it a find-string message?
  1975. if (message == findMessageID ){ 
  1977. // get a pointer to the find structure
  1978. findMessageInfo = (LPFINDREPLACE)lParam;
  1980. // If the FR_DIALOGTERM flag is set, invalidate the find window handle
  1981. if( findMessageInfo->Flags & FR_DIALOGTERM) {
  1982. hWndFind = NULL;
  1983. PrevMatch = FALSE;
  1984.     FindFlags = FindTextInfo.Flags & (FR_DOWN|FR_MATCHCASE|FR_WHOLEWORD);
  1985. return 0;
  1986. }
  1988. // if the FR_FINDNEXT flag is set, go do the search
  1989. if( findMessageInfo->Flags & FR_FINDNEXT ) {
  1990. SetCapture(hWndFind);
  1991. hSaveCursor = SetCursor(hHourGlass);
  1992. EnableWindow( hWndFind, FALSE );
  1993. if( FindInListview( hWnd, findMessageInfo ) ) {
  1994. Autoscroll = FALSE;
  1995. CheckMenuItem( GetMenu(hWnd), IDM_AUTOSCROLL,
  1996. MF_BYCOMMAND|MF_UNCHECKED ); 
  1997. SendMessage( hWndToolbar, TB_CHANGEBITMAP, IDM_AUTOSCROLL, 3 );
  1998. }
  1999. EnableWindow( hWndFind, TRUE );
  2000. ReleaseCapture(); 
  2001. return 0;
  2002. }
  2003. return 0;
  2004. }
  2006. // Default behavior
  2007. return DefWindowProc( hWnd, message, wParam, lParam );
  2008. }
  2009. return FALSE;
  2010. }
  2014. /****************************************************************************
  2015. *
  2016. *    FUNCTION: InitApplication(HANDLE)
  2017. *
  2018. *    PURPOSE: Initializes window data and registers window class
  2019. *
  2020. ****************************************************************************/
  2021. BOOL InitApplication( HANDLE hInstance )
  2022. {
  2023. WNDCLASS  wc;
  2025. // Fill in window class structure with parameters that describe the
  2026. // main (statistics) window. 
  2027. wc.style = 0;                     
  2028. wc.lpfnWndProc = (WNDPROC)MainWndProc; 
  2029. wc.cbClsExtra = 0;              
  2030. wc.cbWndExtra = 0;              
  2031. wc.hInstance = hInstance;       
  2032. wc.hIcon = LoadIcon( hInstance, _T("ICON") );
  2033. wc.hCursor = LoadCursor( NULL, IDC_ARROW );
  2034. wc.hbrBackground = (HBRUSH)(COLOR_INACTIVEBORDER + 1); // Default color
  2035. wc.lpszMenuName = _T("LISTMENU");  
  2036. wc.lpszClassName = _T("RegmonClass");
  2037. if ( ! RegisterClass( &wc ) )
  2038. return FALSE;
  2040. wc.lpszMenuName   = NULL;
  2041.   wc.lpfnWndProc    = (WNDPROC) BalloonDialog;
  2042. wc.hbrBackground  = CreateSolidBrush( 0x00E0FFFF );
  2043. wc.lpszClassName  = "BALLOON";
  2044. RegisterClass( &wc );
  2046. return TRUE;
  2047. }
  2050. /****************************************************************************
  2051. *
  2052. *    FUNCTION:  InitInstance(HANDLE, int)
  2053. *
  2054. *    PURPOSE:  Saves instance handle and creates main window
  2055. *
  2056. ****************************************************************************/
  2057. HWND InitInstance( HANDLE hInstance, int nCmdShow )
  2058. {
  2059. // get the window position settings from the registry
  2060. Get_Position_Settings();
  2062. hInst = hInstance;
  2063. hWndMain = CreateWindow( _T("RegmonClass"), _T("Registry Monitor"), 
  2064. WS_OVERLAPPEDWINDOW,
  2065. PositionInfo.left, PositionInfo.top, 
  2066. PositionInfo.width, PositionInfo.height,
  2067. NULL, NULL, hInstance, NULL );
  2069. // if window could not be created, return "failure" 
  2070. if ( ! hWndMain )
  2071. return NULL;
  2073. // make the window visible; update its client area; and return "success"
  2074. ShowWindow( hWndMain, nCmdShow );
  2075. UpdateWindow( hWndMain ); 
  2077. // maximize it if necessary
  2078. if( PositionInfo.maximized ) {
  2080. ShowWindow( hWndMain, SW_SHOWMAXIMIZED );
  2081. }
  2082. if( OnTop ) {
  2084. SetWindowPos( hWndMain, HWND_TOPMOST, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE );
  2085. CheckMenuItem( GetMenu(hWndMain), IDM_ONTOP,
  2086. MF_BYCOMMAND|(OnTop?MF_CHECKED:MF_UNCHECKED) );
  2087. }
  2088. return hWndMain;      
  2089. }
  2092. /****************************************************************************
  2093. *
  2094. * FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
  2095. *
  2096. * PURPOSE: calls initialization function, processes message loop
  2097. *
  2098. ****************************************************************************/
  2099. int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
  2100. LPSTR lpCmdLine, int nCmdShow )
  2101. {
  2102. MSG  msg;      
  2103. HWND hWnd;
  2104. HACCEL hAccel;
  2105.   DWORD NTVersion;
  2106.         
  2107. if ( ! InitApplication( hInstance ) )
  2108. return FALSE;   
  2110. // get NT version
  2111. NTVersion = GetVersion();
  2112. if( NTVersion >= 0x80000000 ) {
  2114. IsNT = FALSE;
  2116. } else {
  2118. IsNT = TRUE;
  2119. }
  2121. // initializations that apply to a specific instance 
  2122. if ( (hWnd = InitInstance( hInstance, nCmdShow )) == NULL )
  2123. return FALSE;
  2125. // load accelerators
  2126. hAccel = LoadAccelerators( hInstance, _T("ACCELERATORS"));
  2128. // register for the find window message
  2129.     findMessageID = RegisterWindowMessage( FINDMSGSTRING );
  2131. // acquire and dispatch messages until a WM_QUIT message is received.
  2132. while ( GetMessage( &msg, NULL, 0, 0 ) )  {
  2133. if( !TranslateAccelerator( hWnd, hAccel, &msg ) &&
  2134. (!hWndFind || !IsWindow(hWndFind) || !IsDialogMessage( hWndFind, &msg ))) {
  2135. TranslateMessage( &msg );
  2136. DispatchMessage( &msg ); 
  2137. }
  2138. }
  2139. return msg.wParam;  
  2140. }