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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
PWALK.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：45k
源码类别：

Windows编程

开发平台：

Visual C++

PWALK.C：源码内容
  2. /******************************************************************************
  3. *       This is a part of the Microsoft Source Code Samples. 
  4. *       Copyright (C) 1993-1997 Microsoft Corporation.
  5. *       All rights reserved. 
  6. *       This source code is only intended as a supplement to 
  7. *       Microsoft Development Tools and/or WinHelp documentation.
  8. *       See these sources for detailed information regarding the 
  9. *       Microsoft samples programs.
  10. *
  11. *
  12. *  Note:  pwalk will only work correctly with Win32 applications.
  13. *
  14. *
  15. ******************************************************************************/
  17. #include "pwalk.h"
  19. #define strtok      My_mbstok
  21. #define MAX_DRIVES    26    /* maximum number of logical drives */
  23. /* system constants used externally */
  24. int      xChar,
  25.      yChar,
  26.      xScreen,
  27.      yScreen,
  28.      yFrame,
  29.      xFrame,
  30.      yCaption,
  31.      xVScrollBar;
  33. char      szCaptionText[] ="AddressStateProtSizeBaseAddrObjectSectionName";
  34. char      szFormat[] = "%08lX~%s ~%s ~%lu~%08lX~%s ~%s ~%s ~";
  35. SIZE                 sChar0;
  36. char      szFormatPages[] = "%05lX~%s ~%s ~%lu~%05lX~%s ~%s ~%s ~";
  37. int                  taColumns[] = {TA_RIGHT,  TA_LEFT, TA_LEFT, TA_RIGHT,
  38.                                     TA_RIGHT, TA_RIGHT, TA_LEFT,  TA_LEFT,
  39.                                    };
  40. int                  xColumns[]  = {      8,       9,      17,       31,
  41.                                          40,      46,      47,       55,
  42.                                    };
  43. BOOL      bNumbersAsBytes = TRUE;
  44. HFONT      hFontVar;
  46. char      szFilePath[MAX_PATH] = "";
  47. char      szFilename[MAX_PATH] = "";
  48. HFONT      hFont;
  49. LPVOID      lpWalkerList = NULL;
  50. int      *Objects;
  51. int      nSortType = IDM_SORTADDRESS;
  52. HWND      hWndSysStat, hWndProStat, hInitDlg, hMemWnd;
  53. HANDLE      hChildEvents[nDEBUGEVENTS];
  54. DBGPROCESS      *lpChildProcess = NULL;
  55. HMENU      hPopup[MENUPOPUPS];
  56. char      szCurPath[MAX_PATH];
  59. /* local functions */
  60. BOOL   WINAPI InitEnvironment (HANDLE, int, char *);
  61. void   WINAPI InitMenu (HWND);
  62. void   WINAPI DrawListItem (DRAWITEMSTRUCT *);
  63. int    WINAPI MakeVMQString (int, char *);
  64. DWORD  WINAPI VMExceptionFilter (EXCEPTION_POINTERS *);
  65. void   WINAPI SortList (HWND, int);
  66. BOOL   WINAPI ViewableMemorySelection (HWND);
  67. static void TextOutFields (HDC, int, LPRECT, LPSTR);
  70. /****************************************************************************
  71.     My_mbschr:  strchr() DBCS version
  72. ****************************************************************************/
  73. unsigned char * _CRTAPI1 My_mbschr(
  74.     unsigned char *psz, unsigned short uiSep)
  75. {
  76.     while (*psz != '' && *psz != uiSep) {
  77.         psz = CharNext(psz);
  78.     }
  79.     if (*psz == '' && uiSep != '') {
  80.         return NULL;
  81.     } else {
  82.         return psz;
  83.     }
  84. }
  85. /****************************************************************************
  86.     My_mbstok:  strtok() DBCS version
  87. ****************************************************************************/
  88. unsigned char * _CRTAPI1 My_mbstok(
  89.     unsigned char *pszSrc, unsigned char *pszSep)
  90. {
  91.     static char *pszSave = NULL;
  92.     char *pszHead;
  93.     char *psz;
  95.     if (pszSrc == NULL) {
  96.         if (pszSave == NULL) {
  97.             return NULL;
  98.         } else {
  99.             psz = pszSave;
  100.         }
  101.     } else {
  102.         psz = pszSrc;
  103.     }
  105.     /*********************************************/
  106.     /* Skip delimiters to find a head of a token */
  107.     /*********************************************/
  108.     while (*psz) {
  109.         if (IsDBCSLeadByte(*psz)) {
  110.             break;
  111.         } else if (NULL == My_mbschr(pszSep, *psz)) {
  112.             break;
  113.         }
  114.         psz++;
  115.     }
  116.     if (*psz == '') {
  117.         //No more token
  118.         return (pszSave = NULL);
  119.     }
  120.     pszHead = psz;
  122.     /******************************/
  123.     /* Search a Tail of the token */
  124.     /******************************/
  125.     while (*psz) {
  126.         if (IsDBCSLeadByte(*psz)) {
  127.             psz += 2;
  128.             continue;
  129.         } else if (NULL != My_mbschr(pszSep, *psz)) {
  130.             break;
  131.         }
  132.         psz++;
  133.     }
  134.     if (*psz == '') {
  135.         pszSave = NULL;
  136.     } else {
  137.         //Found next delimiter
  138.         pszSave = psz + 1;
  139.         *psz = '';
  140.     }
  141.     return pszHead;
  142. }
  145. /* entry point of this executable */
  146. int WINAPI WinMain (hInstance, hPrevInstance, lpCmdLine, nCmdShow)
  147.     HINSTANCE hInstance;
  148.     HINSTANCE hPrevInstance;
  149.     LPSTR     lpCmdLine;
  150.     int       nCmdShow;
  151. {
  152.     MSG      msg;
  153.     char     *lpszCmdLine = NULL;
  154.     char     *lpCL;
  155.     BOOL     bSwitch;
  157.     /* set current path for use later */
  158.     GetCurrentDirectory (MAX_PATH, szCurPath);
  160.     // parse and copy command line parameters to local memory
  161.     lpCL = GetCommandLine ();
  162.     if (lpszCmdLine = (char *)LocalAlloc (LPTR, strlen (lpCL) + 1))
  163. GetCmdLine (lpCL, lpszCmdLine, &bSwitch);
  165.     /* start window environment */
  166.     if (!InitEnvironment (hInstance, nCmdShow, IsValidFile (lpszCmdLine) ? lpszCmdLine : NULL))
  167. return FALSE;
  169.     /* free memory allocated for lpCmdLine */
  170.     if (lpszCmdLine)
  171. LocalFree ((HLOCAL)lpszCmdLine);
  173.     /* main window message loop */
  174.     while (GetMessage (&msg, NULL, 0, 0))
  175. {
  176. TranslateMessage (&msg);
  177. DispatchMessage (&msg);
  178. }
  180.     /* return success of application */
  181.     return TRUE;
  182. }
  186. /*  start app */
  187. BOOL WINAPI InitEnvironment (
  188.     HANDLE    hInstance,
  189.     int       nCmdShow,
  190.     char      *lpszCmdLine)
  191.     {
  192.     WNDCLASS   wc;
  193.     char       szClass[MAX_PATH];
  194.     char       szTitle[MAX_PATH];
  195.     char       szFilename[MAX_PATH];
  196.     HWND       hWnd;
  199.     /* register system statistics window class */
  200.     LoadString (hInstance, IDS_SYSSTATCLASS, szClass, sizeof (szClass));
  201.     wc.style      = 0;
  202.     wc.lpfnWndProc   = (WNDPROC)SysStatWndProc;
  203.     wc.cbClsExtra    = 0;
  204.     wc.cbWndExtra    = 0;
  205.     wc.hInstance     = hInstance;
  206.     wc.hIcon      = LoadIcon (hInstance, MAKEINTRESOURCE (IDR_SYSSTATICON));
  207.     wc.hCursor      = LoadCursor (0, IDC_ARROW);
  208.     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  209.     wc.lpszMenuName  = NULL;
  210.     wc.lpszClassName = szClass;
  211.     if (!RegisterClass (&wc) )
  212. return FALSE;
  214.     /* register process statistics window class */
  215.     LoadString (hInstance, IDS_PROSTATCLASS, szClass, sizeof (szClass));
  216.     wc.style      = 0;
  217.     wc.lpfnWndProc   = (WNDPROC)ProStatWndProc;
  218.     wc.cbClsExtra    = 0;
  219.     wc.cbWndExtra    = 0;
  220.     wc.hInstance     = hInstance;
  221.     wc.hIcon      = LoadIcon (hInstance, MAKEINTRESOURCE (IDR_PROSTATICON));
  222.     wc.hCursor      = LoadCursor (0, IDC_ARROW);
  223.     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  224.     wc.lpszMenuName  = NULL;
  225.     wc.lpszClassName = szClass;
  226.     if (!RegisterClass (&wc) )
  227. return FALSE;
  229.     /* register the status bar window class */
  230.     LoadString (hInstance, IDS_STATUSCLASS, szClass, sizeof (szClass));
  231.     wc.style      = 0;
  232.     wc.lpfnWndProc   = (WNDPROC)StatusWndProc;
  233.     wc.cbClsExtra    = 0;
  234.     wc.cbWndExtra    = STATUSWXB;
  235.     wc.hInstance     = hInstance;
  236.     wc.hIcon      = (HICON)NULL;
  237.     wc.hCursor      = LoadCursor (0, IDC_ARROW);
  238.     wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
  239.     wc.lpszMenuName  = NULL;
  240.     wc.lpszClassName = szClass;
  241.     if (!RegisterClass (&wc) )
  242. return FALSE;
  244.     /* register the main frame window class */
  245.     LoadString (hInstance, IDS_MEMVIEWCLASS, szClass, sizeof (szClass));
  246.     wc.style      = 0;
  247.     wc.lpfnWndProc   = (WNDPROC)MemWndProc;
  248.     wc.cbClsExtra    = 0;
  249.     wc.cbWndExtra    = VIEWWXB;
  250.     wc.hInstance     = hInstance;
  251.     wc.hIcon      = LoadIcon (hInstance, MAKEINTRESOURCE (IDR_MAINICON));
  252.     wc.hCursor      = LoadCursor (0, IDC_ARROW);
  253.     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  254.     wc.lpszMenuName  = NULL;
  255.     wc.lpszClassName = szClass;
  256.     if (!RegisterClass (&wc) )
  257. return FALSE;
  259.     /* register the main frame window class */
  260.     LoadString (hInstance, IDS_WALKERCLASS, szClass, sizeof (szClass));
  261.     wc.style      = 0;
  262.     wc.lpfnWndProc   = (WNDPROC)WalkerWndProc;
  263.     wc.cbClsExtra    = 0;
  264.     wc.cbWndExtra    = 0;
  265.     wc.hInstance     = hInstance;
  266.     wc.hIcon      = LoadIcon (hInstance, MAKEINTRESOURCE (IDR_MAINICON));
  267.     wc.hCursor      = LoadCursor (0, IDC_ARROW);
  268.     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  269.     wc.lpszMenuName  = MAKEINTRESOURCE (IDR_WALKERMENU);
  270.     wc.lpszClassName = szClass;
  271.     if (!RegisterClass (&wc) )
  272. return FALSE;
  274.     /* create window caption */
  275.     LoadString (hInstance, IDS_CAPTION, szTitle, sizeof (szTitle));
  276.     if (lpszCmdLine != NULL &&
  277. ((lpChildProcess = StartChildProcess (NULL, lpszCmdLine, hChildEvents)) != NULL))
  278. GetFileFromPath (lpszCmdLine, szFilename);
  279.     else
  280. LoadString (hInstance, IDS_SELF, szFilename, MAX_PATH);
  281.     strcat (szTitle, szFilename);
  283.     /* create main frame window */
  284.     hWnd = CreateWindow (szClass,
  285.  szTitle,
  286.  WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
  287.  CW_USEDEFAULT,
  288.  0,
  289.  CW_USEDEFAULT,
  290.  0,
  291.  NULL,
  292.  NULL,
  293.  hInstance,
  294.  NULL);
  296.     /* update parent window handle in child process information structure */
  297.     if (lpChildProcess != NULL)
  298. lpChildProcess->hWnd = hWnd;
  300.     if (!hWnd)
  301. return 0;
  303.     ShowWindow (hWnd, nCmdShow);
  304.     UpdateWindow (hWnd);
  305.     return TRUE;
  306. }
  309. /* main window procedure */
  310. LONG WINAPI WalkerWndProc (
  311.     HWND    hWnd,
  312.     UINT    uMsg,
  313.     WPARAM  wParam,
  314.     LPARAM  lParam)
  315. {
  316.        LONG    lRet = 1;
  318. static LOGFONT lf_Font = {
  319.  -10, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  320.  OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  321.  DEFAULT_QUALITY, FIXED_PITCH | FF_DONTCARE,
  322.                          "Courier",
  323.  };
  324. static LOGFONT lf_FontVar = {
  325.     -10, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
  326.  OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  327.  DEFAULT_QUALITY, 0, // FIXED_PITCH | FF_DONTCARE,
  328.                          "MS Sans Serif",
  329.  };
  332.     /* On a Japanese system, change the fonts...  should generalize to all FE */
  333.     if (PRIMARYLANGID(GetUserDefaultLangID ()) == LANG_JAPANESE) {
  334.         lf_Font.lfCharSet = SHIFTJIS_CHARSET;
  335.         lstrcpy (lf_Font.lfFaceName , "Terminal");
  337.         lf_FontVar.lfHeight= -12;
  338.         lf_FontVar.lfCharSet = SHIFTJIS_CHARSET;
  339.         lstrcpy (lf_Font.lfFaceName , "俵俽 僑僔僢僋");
  340.     }
  344.     switch (uMsg)
  345. {
  346. /* initialize menu before drawing */
  347. case WM_INITMENU:
  348.     InitMenu (hWnd);
  349.     break;
  351. /* display status messages for menu commands */
  352. case WM_MENUSELECT:
  353.     {
  354.     char     *lpszMenuString;
  356.     lpszMenuString = LocalAlloc (LPTR, MAX_PATH);
  358.     if (HIWORD (wParam) ==  0xFFFF)
  359. {
  360. LocalFree (lpszMenuString);
  361. lpszMenuString = NULL;
  362. }
  364.     else if (HIWORD (wParam) & MF_POPUP)
  365. {
  366. int  i;
  367. HMENU  hPopupMenu = GetSubMenu ((HMENU)lParam, LOWORD (wParam));
  369. lpszMenuString = LocalAlloc (LPTR, MAX_PATH);
  371. for (i=0; i<MENUPOPUPS; i++)
  372.     {
  373.     if (hPopup[i] == hPopupMenu)
  374. {
  375. LoadString (GetModuleHandle (NULL),
  376.     i+IDM_POPUPMENUS,
  377.     lpszMenuString,
  378.     MAX_PATH);
  379. break;
  380. }
  381.     }
  382. }
  383.     else
  384. LoadString (GetModuleHandle (NULL),
  385.     LOWORD (wParam),
  386.     lpszMenuString,
  387.     MAX_PATH);
  389.     /* send the status string, gray if necessary */
  390.     SendMessage (GetDlgItem (hWnd, IDC_STATUSWND),
  391.  WM_SETTEXT,
  392.  (HIWORD (wParam) & MF_GRAYED) ?
  393.      (LPARAM)GetSysColor (COLOR_GRAYTEXT):
  394.      0,
  395.  (WPARAM)lpszMenuString);
  397.     LocalFree (lpszMenuString);
  398.     }
  399.     break;
  401. case WM_CREATE:
  402.     {
  403.     HCURSOR   hOldCursor;
  404.     HDC    hDC;
  405.     TEXTMETRIC   tm;
  406.     char   szWndClass[MAX_PATH];
  407.     HWND   hList, hStatus;
  408.     int    i=0, j, k;
  409.     HMENU   hMenu;
  411.     /* build array of popup menu handles */
  412.     hMenu = GetMenu (hWnd);
  413.     for (k=0; k<MENUPOPUPS-(i-1); k++)
  414. {
  415. hPopup[i] = GetSubMenu (hMenu, k);
  416. j=0;
  417. while ((hPopup[i+j+1] = GetSubMenu (hPopup[i], j)) != NULL)
  418.     j++;
  419. if (j)
  420.     i+=j;
  421. i++;
  422. }
  424.     /* put hourglass cursor up */
  425.     hOldCursor = (HCURSOR)SetClassLong (hWnd, GCL_HCURSOR, 0);
  426.     SetCursor (LoadCursor (0, IDC_WAIT));
  428.     hDC = GetDC(hWnd);
  430.     /* want a font with point size of 10 (smallest size it comes in) */
  431.     lf_Font.lfHeight = -(10 * GetDeviceCaps(hDC, LOGPIXELSY)/72);
  432.     hFont = CreateFontIndirect(&lf_Font);
  433.     hFontVar = CreateFontIndirect(&lf_FontVar);
  436.             // find the width of a '0' in the variable font
  437.             //
  438.             SelectObject(hDC, hFontVar);
  439.             GetTextExtentPoint (hDC, "0", 1, &sChar0);
  441.             SelectObject(hDC, hFont);
  443.     /* initialize system constants */
  444.     GetTextMetrics(hDC, &tm);
  445.     yChar = tm.tmHeight;
  446.     xChar = tm.tmAveCharWidth;
  447.     xScreen = GetSystemMetrics(SM_CXSCREEN);
  448.     yScreen = GetSystemMetrics(SM_CYSCREEN);
  449.     yFrame = GetSystemMetrics(SM_CYFRAME);
  450.     xFrame = GetSystemMetrics(SM_CXFRAME);
  451.     yCaption = GetSystemMetrics(SM_CYCAPTION);
  452.     xVScrollBar = GetSystemMetrics(SM_CXVSCROLL);
  454.     //Actually, it's not good that a width of each column
  455.     // depends on a width of "0"!!
  456.     if (xChar > sChar0.cx) {
  457. // sChar0.cx = xChar;
  458. sChar0.cx = sChar0.cx * 12 / 10; //sChar0.cx *= 1.2
  459.     }
  461.             SelectObject(hDC, GetStockObject(SYSTEM_FONT));
  462.             ReleaseDC(hWnd, hDC);
  464.     /* create listbox for client area */
  465.     LoadString (GetModuleHandle (NULL),
  466. IDS_LISTBOX,
  467. szWndClass,
  468. sizeof (szWndClass));
  469.     hList = CreateWindow (szWndClass,
  470.   NULL,
  471.   WS_CHILD | WS_VISIBLE | WS_VSCROLL |
  472.   LBS_EXTENDEDSEL | LBS_NOTIFY | LBS_OWNERDRAWFIXED |
  473.   LBS_WANTKEYBOARDINPUT | LBS_NOINTEGRALHEIGHT,
  474.   0, 0, 0, 0,
  475.   hWnd,
  476.   (HMENU)IDC_LISTBOX,
  477.   GetModuleHandle (NULL),
  478.   NULL);
  480.     /* if listbox failed, abort app */
  481.     if (!IsWindow (hList))
  482. DestroyWindow(hWnd);
  483.     SendMessage (hList, WM_SETFONT, (WPARAM)hFontVar, 0L);
  485.     /* create status window for client area */
  486.     LoadString (GetModuleHandle (NULL),
  487. IDS_STATUSCLASS,
  488. szWndClass,
  489. sizeof (szWndClass));
  490.     if (!(hStatus = CreateWindow (szWndClass,
  491.   NULL,
  492.   WS_CHILD | WS_VISIBLE | WS_BORDER,
  493.   0, 0, 0, 0,
  494.   hWnd,
  495.   (HMENU)IDC_STATUSWND,
  496.   GetModuleHandle (NULL),
  497.   NULL)))
  498. ReportError (IDS_ERRCREATEWINDOW);
  500.     /* initialize status window */
  501.     SendMessage (GetDlgItem (hWnd, IDC_STATUSWND),
  502.  UM_UPDATE,
  503.  (WPARAM)lpChildProcess,
  504.  0);
  506.     /* if child process post message to display initialization dialog */
  507.     if (lpChildProcess != NULL)
  508. PostMessage (hWnd, UM_STARTINITDIALOG, 0, 0);
  510.     /* remove hourglass cursor */
  511.     SetClassLong (hWnd, GCL_HCURSOR, (LONG)hOldCursor);
  512.     SetCursor (hOldCursor);
  513.     }
  514.     break;
  516. case UM_STARTINITDIALOG:
  517.     /* start modal initializing information window */
  518.     DialogBoxParam (GetModuleHandle (NULL),
  519.     (char *)IDD_INITIALIZING,
  520.     hWnd,
  521.     InitDlgProc,
  522.     (LPARAM)&hInitDlg);
  523.     hInitDlg = NULL;
  524.     break;
  526. case WM_SETFOCUS:
  527.     /* keep focus in listbox when possible */
  528.     SetFocus (GetDlgItem (hWnd, IDC_LISTBOX));
  529.     break;
  531. case WM_MEASUREITEM:
  532.             ((MEASUREITEMSTRUCT FAR *)lParam)->itemHeight = sChar0.cy;
  533.             break;
  535. case WM_DRAWITEM:
  536.     DrawListItem ((DRAWITEMSTRUCT FAR *)lParam);
  537.             break;
  539. case WM_PAINT:
  540.     {
  541.     PAINTSTRUCT ps;
  542.     RECT rc;
  544.     /* draw the caption line above the list box */
  545.     BeginPaint(hWnd, &ps);
  546.     SetRect(&rc, 0, 0, GetSystemMetrics (SM_CXSCREEN), sChar0.cy);
  548.     SelectObject(ps.hdc, hFontVar);
  549.     SetTextColor(ps.hdc, GetSysColor(COLOR_CAPTIONTEXT));
  550.     SetBkColor(ps.hdc, GetSysColor(COLOR_ACTIVECAPTION));
  551.             TextOutFields (ps.hdc, 6, &rc, szCaptionText);
  552.     SelectObject(ps.hdc, GetStockObject(SYSTEM_FONT));
  553.     EndPaint(hWnd, &ps);
  554.     }
  555.     break;
  557. case WM_SIZE:
  558.     /* size listbox and status bar */
  559.     if ((wParam == SIZE_RESTORED) || (wParam == SIZE_MAXIMIZED))
  560. {
  561. int    yBorder = GetSystemMetrics (SM_CYBORDER);
  562. int    xBorder = GetSystemMetrics (SM_CXBORDER);
  563. int    yStatus = yChar + 10*yBorder;
  565. /* size listbox */
  566. MoveWindow(GetDlgItem (hWnd, IDC_LISTBOX),
  567.    0,
  568.    sChar0.cy,
  569.    LOWORD(lParam),
  570.    HIWORD(lParam)-(sChar0.cy + yStatus - yBorder),
  571.    TRUE);
  573. /* size status bar */
  574. MoveWindow(GetDlgItem (hWnd, IDC_STATUSWND),
  575.    0-xBorder,
  576.    HIWORD(lParam)-yStatus+yBorder,
  577.    LOWORD(lParam) + 2*xBorder,
  578.    yStatus,
  579.    TRUE);
  580. }
  581.     break;
  583. case WM_COMMAND:
  584.     {
  585.     switch (LOWORD (wParam))
  586. {
  587. case IDM_EXIT:
  588.     SendMessage (hWnd, WM_CLOSE, 0, 0);
  589.     break;
  591. case IDM_PROCESSUNLOAD:
  592.     {
  593.     char    szFilename[MAX_PATH];
  594.     char    szTitle[MAX_PATH];
  595.     HWND    hViewWnd = NULL;
  597.     /* close child process */
  598.     CloseChildProcess (lpChildProcess, hChildEvents);
  599.     lpChildProcess = NULL;
  600.     SendMessage (GetDlgItem (hWnd, IDC_LISTBOX), LB_RESETCONTENT, 0, 0);
  601.     SendMessage (GetDlgItem (hWnd, IDC_STATUSWND),
  602.  UM_UPDATE,
  603.  0,
  604.  0);
  606.     /* reset caption */
  607.     LoadString (GetModuleHandle (NULL),
  608. IDS_CAPTION,
  609. szTitle,
  610. MAX_PATH);
  611.     LoadString (GetModuleHandle (NULL),
  612. IDS_SELF,
  613. szFilename,
  614. MAX_PATH);
  615.     strcat (szTitle, szFilename);
  616.     SetWindowText (hWnd, szTitle);
  618.     if (IsWindow (hWndSysStat))
  619. {
  620. InvalidateRect (hWndSysStat, NULL, TRUE);
  621. UpdateWindow (hWndSysStat);
  622. }
  624.     if (IsWindow (hWndProStat))
  625. DestroyWindow (hWndProStat);
  627.     while ((hViewWnd = EnumViewWindows (hWnd, hViewWnd)) != NULL)
  628. DestroyWindow (hViewWnd);
  629.     }
  630.     break;
  632. case IDM_PROCESSLOAD:
  633.     {
  634.     char      szTitle[MAX_PATH];
  635.     char      szFilePath[MAX_PATH];
  636.     HWND      hViewWnd = NULL;
  638.     /* detaching from old process, okay?? */
  639.     if (lpChildProcess != NULL)
  640. {
  641. strcpy (szTitle, "Detach from process ");
  642. strcat (szTitle, lpChildProcess->szModule);
  643. strcat (szTitle, "?");
  645. LoadString (GetModuleHandle (NULL),
  646.     IDS_WALKERCLASS,
  647.     szFilePath,
  648.     MAX_PATH);
  649. if (IDYES != MessageBox (hWnd,
  650.  szTitle,
  651.  szFilePath,
  652.  MB_YESNO | MB_ICONQUESTION))
  653.     break;
  654. }
  656.     /* call open file dialog to get filename of exe, and validate */
  657.     *szFilePath = 0;
  658.     if (GetFileName (hWnd, szFilePath, NULL))
  659. {
  660. if (IsValidFile (szFilePath))
  661.     {
  662.     if (lpChildProcess != NULL)
  663. {
  664. /* close any open view windows for this process */
  665. while ((hViewWnd = EnumViewWindows (hWnd, hViewWnd)) != NULL)
  666.     DestroyWindow (hViewWnd);
  668. CloseChildProcess (lpChildProcess, hChildEvents);
  669. SendMessage (GetDlgItem (hWnd, IDC_LISTBOX),
  670.      LB_RESETCONTENT,
  671.      0,
  672.      0);
  673. SendMessage (GetDlgItem (hWnd, IDC_STATUSWND),
  674.      UM_UPDATE,
  675.      0,
  676.      0);
  677. }
  679.     if ((lpChildProcess =
  680.  StartChildProcess (hWnd, szFilePath, hChildEvents)) != NULL)
  681. {
  682. /* force rewalk of process */
  683. PostMessage (hWnd, UM_STARTINITDIALOG, 0, 0);
  684. SendMessage (GetDlgItem (hWnd, IDC_STATUSWND),
  685.      UM_UPDATE,
  686.      (WPARAM)lpChildProcess,
  687.      0);
  689. /* load new window caption */
  690. LoadString (GetModuleHandle (NULL),
  691.     IDS_CAPTION,
  692.     szTitle,
  693.     MAX_PATH);
  695. GetFileFromPath (szFilePath, szFilename);
  696. strcat (szTitle, szFilename);
  697. SetWindowText (hWnd, szTitle);
  698. }
  699.     }
  700. }
  701.     }
  702.     break;
  704. case IDM_PROCESSREWALK:
  705.     {
  706.     HWND      hList = GetDlgItem (hWnd, IDC_LISTBOX);
  707.     int       nCnt, nNewCnt, i;
  708.     LPVOID    lpNewList=NULL, lpTempList=NULL;
  709.     HWND      hViewWnd = NULL;
  712.     /* clear listbox of current contents, but first find out how many exist */
  713.     nCnt = SendMessage (hList, LB_GETCOUNT, 0, 0);
  714.     SendMessage (hList, WM_SETREDRAW, 0, 0);
  715.     SendMessage (hList, LB_RESETCONTENT, 0, 0);
  717.     /* walk process address space */
  718.     if (lpChildProcess != NULL)
  719. {
  720. nNewCnt = WalkProcess (lpChildProcess->hProcess, &lpNewList, &Objects);
  721. AnalyzeProcess (lpChildProcess, (LPVMOBJECT)lpNewList, nNewCnt);
  723. /* indentify which objects are new */
  724. if (nCnt)
  725.     IdentifyNewObjects (lpWalkerList, nCnt, lpNewList, nNewCnt);
  727. /* free old list and update cnt */
  728. lpTempList = lpWalkerList;
  729. lpWalkerList = lpNewList;
  730. VirtualFree (lpTempList, TOTALVMRESERVE, MEM_DECOMMIT);
  731. VirtualFree (lpTempList, 0, MEM_RELEASE);
  732. nCnt = nNewCnt;
  733. }
  735.     for (i=0; i<nCnt; i++)
  736. SendMessage (hList, LB_ADDSTRING, 0, i);
  738.     /* sort if other than by address is selected */
  739.     if (nSortType != IDM_SORTADDRESS)
  740. SortList (hList, nSortType);
  742.     /* reenable redraw of listbox */
  743.     SendMessage (hList, WM_SETREDRAW, 1, 0);
  744.     InvalidateRect (hList, NULL, TRUE);
  745.     UpdateWindow (hList);
  747.     /* if any memory view windows, send update message */
  748.     while ((hViewWnd = EnumViewWindows (hWnd, hViewWnd)) != NULL)
  749. {
  750. LPMEMVIEW     pmv, pmvOld;
  751. int     nAddress, nSize;
  752. MEMORY_BASIC_INFORMATION    mbi;
  753. char     *szCaption;
  755. /* retrieve view memory range */
  756. szCaption = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, MAX_PATH);
  757. GetWindowText (hViewWnd, szCaption, MAX_PATH);
  759. /* validate range */
  760. sscanf (strtok (szCaption, "-"), "%8x", &nAddress);
  761. sscanf (strtok (NULL, " "), "%8x", &nSize);
  762. nSize -= nAddress;
  763. VirtualQueryEx (lpChildProcess->hProcess,
  764. (LPVOID)nAddress,
  765. &mbi,
  766. sizeof (MEMORY_BASIC_INFORMATION));
  768. if (mbi.State != MEM_COMMIT)
  769.     {
  770.     NotifyUser (hWnd, IDS_ERROR, IDS_NOTCOMMITTEDMEMORY, NULL, 0);
  771.     DestroyWindow (hViewWnd);
  772.     goto NOT;
  773.     }
  775. /* if size of committed region changed, update caption */
  776. if (mbi.RegionSize != (DWORD)nSize)
  777.     {
  778.     wsprintf (szCaption,
  779.       "%4lx-%-4lx",
  780.       (DWORD)mbi.BaseAddress,
  781.       (DWORD)mbi.BaseAddress+mbi.RegionSize);
  782.     SetWindowText (hViewWnd, szCaption);
  783.     }
  785. /* free default heap memory */
  786. HeapFree (GetProcessHeap (), 0, szCaption);
  788. /* if an old view structure existed, release virtual memory */
  789. if ((pmvOld = (LPMEMVIEW)GetWindowLong (hViewWnd, WXB_LPOLDMEMVIEW)) != NULL)
  790.     VirtualFree (pmvOld->lpMem, 0, MEM_RELEASE);
  792. pmvOld = (LPMEMVIEW)GetWindowLong (hViewWnd, WXB_LPMEMVIEW);
  793. /* save past pmv for update comparison */
  794. SetWindowLong (hViewWnd,
  795.        WXB_LPOLDMEMVIEW,
  796.        (LONG)pmvOld);
  798. /* allocate memory structure for view memory object */
  799. pmv = (LPMEMVIEW)LocalAlloc (LPTR, sizeof (MEMVIEW));
  801. /* copy old mem view to new mem view */
  802. for (i=0; i<sizeof (MEMVIEW); i++)
  803.     ((LPBYTE)pmv)[i] = ((LPBYTE)pmvOld)[i];
  805. /* update structure for new mem structure */
  806. pmv->nBase = (int)mbi.BaseAddress;
  807. pmv->nSize = (int)mbi.RegionSize;
  809. if ((pmv->lpMem = VirtualAlloc (NULL, pmv->nSize, MEM_COMMIT, PAGE_READWRITE)) == NULL)
  810.     {
  811.     ReportError (IDS_ERRVIRTUALALLOC);
  812.     DestroyWindow (hViewWnd);
  813.     }
  815. else if (AccessProcessMemory (hChildEvents[READMEMORY],
  816.       hChildEvents[ACKNOWLEDGE],
  817.       (LPVOID)nAddress,
  818.       pmv->lpMem,
  819.       &(pmv->nSize))  && pmv->nSize)
  820.     {
  821.     pmv->nLines = (pmv->nSize+15)/16;
  822.     pmv->nExtraBytes = (pmv->nSize & 0x0000000F);
  823.     SetWindowLong (hViewWnd, WXB_LPMEMVIEW, (LONG)pmv);
  825.     /* post message to view window to update */
  826.     PostMessage (hViewWnd, UM_UPDATE, 0, 0);
  827.     }
  829. else
  830.     {
  831.     NotifyUser (hWnd, IDS_ERROR, IDS_COULDNOTREADPROCESS, NULL, 0);
  832.     DestroyWindow (hViewWnd);
  833.     }
  835. }
  837. NOT:
  838.     /* if initialization dialog, send notification to remove */
  839.     if (IsWindow (hInitDlg))
  840. PostMessage (hInitDlg, UM_ENDDIALOG, 0, 0);
  841.     }
  842.     break;
  844. case IDM_PROCESSSUSPEND:
  845.     SetEvent (hChildEvents[SUSPENDDEBUGGER]);
  846.     break;
  848. case IDM_PROCESSRESUME:
  849.     SetEvent (hChildEvents[RESUMEDEBUGGER]);
  850.     break;
  852. case IDM_VIEWSYSSTAT:
  853.     /* if window exists, destroy it */
  854.     if (IsWindow (hWndSysStat))
  855. {
  856. DestroyWindow (hWndSysStat);
  857. CheckMenuItem (GetMenu (hWnd), wParam, MF_UNCHECKED);
  858. }
  859.     else
  860. {
  861. char szClass[100];
  862. char szTitle[100];
  863. RECT rc;
  865. GetWindowRect (hWnd, &rc);
  866. LoadString (GetModuleHandle (NULL), IDS_SYSSTATCLASS, szClass, 100);
  867. LoadString (GetModuleHandle (NULL), IDS_SYSSTATTITLE, szTitle, 100);
  868. hWndSysStat = CreateWindow (szClass,
  869.     szTitle,
  870.     WS_POPUP | WS_CAPTION | WS_MINIMIZEBOX |
  871.     WS_SYSMENU | WS_DLGFRAME | WS_VISIBLE,
  872.     rc.left+50, rc.top+50, 500, 270,
  873.     hWnd,
  874.     NULL,
  875.     GetModuleHandle (NULL),
  876.     NULL);
  877. UpdateWindow (hWndSysStat);
  878. ShowWindow (hWndSysStat, SW_SHOWNORMAL);
  879. CheckMenuItem (GetMenu (hWnd), wParam, MF_CHECKED);
  880. }
  881.     break;
  883. case IDM_VIEWPROSTAT:
  884.     /* if window exists, destroy it */
  885.     if (IsWindow (hWndProStat))
  886. {
  887. DestroyWindow (hWndProStat);
  888. CheckMenuItem (GetMenu (hWnd), wParam, MF_UNCHECKED);
  889. }
  890.     else
  891. {
  892. char szClass[100];
  893. char szTitle[100];
  894. RECT rc;
  896. GetWindowRect (hWnd, &rc);
  897. LoadString (GetModuleHandle (NULL), IDS_PROSTATCLASS, szClass, 100);
  898. LoadString (GetModuleHandle (NULL), IDS_PROSTATTITLE, szTitle, 100);
  899. hWndProStat = CreateWindow (szClass,
  900.     szTitle,
  901.     WS_POPUP | WS_CAPTION | WS_MINIMIZEBOX |
  902.     WS_SYSMENU | WS_DLGFRAME | WS_VISIBLE,
  903.     rc.left+75, rc.top+75, 355, 120,
  904.     hWnd,
  905.     NULL,
  906.     GetModuleHandle (NULL),
  907.     NULL);
  908. UpdateWindow (hWndProStat);
  909. ShowWindow (hWndProStat, SW_SHOWNORMAL);
  910. CheckMenuItem (GetMenu (hWnd), wParam, MF_CHECKED);
  911. }
  912.     break;
  914. /* accept bouble click messages from listbox only */
  915. case IDC_LISTBOX:
  916.     if (HIWORD (wParam) != LBN_DBLCLK)
  917. break;
  919. case IDM_VIEWMEMORY:
  920.     if (ViewableMemorySelection (hWnd))
  921. {
  922. char   szBuff[50];
  923. HWND   hList = GetDlgItem (hWnd, IDC_LISTBOX);
  924. int   iCaret = SendMessage (hList, LB_GETCARETINDEX, 0, 0);
  925. DWORD   nAddress =
  926.   (DWORD)((LPVMOBJECT)lpWalkerList)[Objects[iCaret]].mbi.BaseAddress;
  927. int   nSize = ((LPVMOBJECT)lpWalkerList)[Objects[iCaret]].mbi.RegionSize;
  928. LPVOID   lpMem;
  929. HCURSOR   hOldCursor;
  931. if ((lpMem = VirtualAlloc (NULL, nSize, MEM_COMMIT, PAGE_READWRITE)) == NULL)
  932.     {
  933.     ReportError (IDS_ERRVIRTUALALLOC);
  934.     break;
  935.     }
  937. /* put wait cursor up */
  938. hOldCursor = (HCURSOR)SetClassLong (hWnd, GCL_HCURSOR, 0);
  939. SetCursor (LoadCursor (0, IDC_WAIT));
  941. /* signal debugger thread to read process memory */
  942. if (AccessProcessMemory (hChildEvents[READMEMORY],
  943.  hChildEvents[ACKNOWLEDGE],
  944.  (LPVOID)nAddress,
  945.  lpMem,
  946.  &nSize)  && nSize)
  947.     {
  948.     wsprintf (szBuff, "%4lx-%-4lx", nAddress, nAddress+nSize);
  949.     ViewMemory (hWnd, szBuff, lpMem, nSize, nAddress);
  951.     /* if first view window, add separator */
  952.     if (GetMenuItemCount (GetSubMenu (GetMenu (hWnd), 2)) == 5)
  953. AppendMenu (GetSubMenu (GetMenu (hWnd), 2),
  954.     MF_SEPARATOR,
  955.     0,
  956.     NULL);
  958.     AppendMenu (GetSubMenu (GetMenu (hWnd), 2),
  959. MF_STRING | MF_CHECKED,
  960. AddAtom (szBuff),
  961. szBuff);
  962.     }
  964. else
  965.     NotifyUser (hWnd, IDS_ERROR, IDS_COULDNOTREADPROCESS, NULL, 0);
  968. /* replace wait cursor with old cursor */
  969. SetClassLong (hWnd, GCL_HCURSOR, (LONG)hOldCursor);
  970. SetCursor (hOldCursor);
  971. }
  972.     else
  973. {
  974. NotifyUser (hWnd, IDS_ERROR, IDS_NOTCOMMITTEDMEMORY, NULL, 0);
  975. break;
  976. }
  977.     break;
  979. case IDM_VIEWADDRESS:
  980.     {
  981.     int  nAddress;
  982.     MEMORY_BASIC_INFORMATION mbi;
  983.     LPVOID lpMem;
  984.     char szBuff[MAX_PATH];
  985.     int  nLine;
  986.     HWND hViewWnd;
  989.     if (nAddress = DialogBox (GetModuleHandle (NULL), (char *)IDD_ADDR, hWnd, AddrDlgProc))
  990. {
  991. VirtualQueryEx (lpChildProcess->hProcess,
  992. (LPVOID)nAddress,
  993. &mbi,
  994. sizeof (MEMORY_BASIC_INFORMATION));
  996. if (mbi.State != MEM_COMMIT)
  997.     {
  998.     NotifyUser (hWnd, IDS_ERROR, IDS_NOTCOMMITTEDMEMORY, NULL, 0);
  999.     break;
  1000.     }
  1002. if ((lpMem = VirtualAlloc (NULL, mbi.RegionSize, MEM_COMMIT, PAGE_READWRITE)) == NULL)
  1003.     {
  1004.     ReportError (IDS_ERRVIRTUALALLOC);
  1005.     break;
  1006.     }
  1008. /* signal debugger thread to read process memory */
  1009. if (AccessProcessMemory (hChildEvents[READMEMORY],
  1010.  hChildEvents[ACKNOWLEDGE],
  1011.  (LPVOID)mbi.BaseAddress,
  1012.  lpMem,
  1013.  &(mbi.RegionSize))  && mbi.RegionSize)
  1014.     {
  1015.     wsprintf (szBuff,
  1016.       "%4lx-%-4lx",
  1017.       (int)mbi.BaseAddress,
  1018.       (int)mbi.BaseAddress+mbi.RegionSize);
  1020.     hViewWnd = ViewMemory (hWnd, szBuff, lpMem, mbi.RegionSize, (int)mbi.BaseAddress);
  1022.     /* if first view window, add separator */
  1023.     if (GetMenuItemCount (GetSubMenu (GetMenu (hWnd), 2)) == 4)
  1024. AppendMenu (GetSubMenu (GetMenu (hWnd), 2),
  1025.     MF_SEPARATOR,
  1026.     0,
  1027.     NULL);
  1029.     AppendMenu (GetSubMenu (GetMenu (hWnd), 2),
  1030. MF_STRING | MF_CHECKED,
  1031. AddAtom (szBuff),
  1032. szBuff);
  1034.     /* send WM_VSCROLL message to scroll address into view */
  1035.     nLine = (nAddress - (int)mbi.BaseAddress)/16 - 5;
  1036.     PostMessage (hViewWnd, WM_VSCROLL, MAKELONG (SB_THUMBPOSITION, nLine), 0);
  1037.     }
  1039. else
  1040.     NotifyUser (hWnd, IDS_ERROR, IDS_COULDNOTREADPROCESS, NULL, 0);
  1041. }
  1042.     }
  1043.     break;
  1045. case IDM_REMOVEVIEWWND:
  1046.     {
  1047.     ATOM    aCaption = FindAtom ((char *)lParam);
  1048.     HMENU   hMenu = GetMenu (hWnd);
  1049.     HMENU   hViewMenu = GetSubMenu (hMenu, 2);
  1051.     RemoveMenu (hMenu, (UINT)aCaption, MF_BYCOMMAND);
  1052.     DeleteAtom (aCaption);
  1054.     /* there are 4 menuitems in the view menu without view windows open */
  1055.     if (GetMenuItemCount (hViewMenu) == 6)
  1056. RemoveMenu (hViewMenu, 5, MF_BYPOSITION);
  1057.     }
  1058.     break;
  1060. case IDM_SORTADDRESS:
  1061. case IDM_SORTSTATE:
  1062. case IDM_SORTPROTECTION:
  1063. case IDM_SORTSIZE:
  1064. case IDM_SORTBASEADDRESS:
  1065.     {
  1066.     HWND    hList = GetDlgItem (hWnd, IDC_LISTBOX);
  1067.     HCURSOR hOldCursor;
  1069.     if (nSortType != (int)LOWORD (wParam))
  1070. {
  1071. /* put wait cursor up */
  1072. hOldCursor = (HCURSOR)SetClassLong (hWnd, GCL_HCURSOR, 0);
  1073. SetCursor (LoadCursor (0, IDC_WAIT));
  1075. /* reset menuitems to indicate which sort method is being used */
  1076. CheckMenuItem (GetMenu (hWnd), nSortType, MF_UNCHECKED);
  1077. CheckMenuItem (GetMenu (hWnd), wParam, MF_CHECKED);
  1079. /* save new sort type and resort */
  1080. SortList (hList, nSortType = wParam);
  1082. /* repaint after sorting */
  1083. InvalidateRect (hList, NULL, TRUE);
  1084. UpdateWindow (hList);
  1086. /* replace wait cursor with old cursor */
  1087. SetClassLong (hWnd, GCL_HCURSOR, (LONG)hOldCursor);
  1088. SetCursor (hOldCursor);
  1089.  }
  1090.     }
  1091.     break;
  1093.                 case IDM_OPTBYTES:
  1094.                 case IDM_OPTPAGES:
  1095.                     {
  1096.                     HWND hList = GetDlgItem (hWnd, IDC_LISTBOX);
  1097.                     bNumbersAsBytes = (LOWORD(wParam) == IDM_OPTBYTES);
  1098.                     InvalidateRect (hList, NULL, TRUE);
  1099.                     }
  1100.                     break;
  1102. default:
  1103.     /* if popup window, bring to front */
  1104.     ActivateViewWindow (LOWORD (wParam));
  1105.     lRet = TRUE;
  1106.     break;
  1107. }
  1108.     }
  1109.     break;
  1111. case WM_CLOSE:
  1112. case WM_QUERYENDSESSION:
  1113.     /* if child process is active, close it first then exit */
  1114.     if (lpChildProcess != NULL)
  1115. CloseChildProcess (lpChildProcess, hChildEvents);
  1117.     /* destroy this window */
  1118.     DestroyWindow (hWnd);
  1119.     break;
  1121. case WM_DESTROY:
  1122.     PostQuitMessage (0);
  1123.     break;
  1125. default:
  1126.     /* pass all unhandled messages to DefWindowProc */
  1127.     lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
  1128.     break;
  1129. }
  1131.     /* return 1 if handled message, 0 if not */
  1132.     return lRet;
  1133. }
  1137. /* initialize all menuitems */
  1138. void WINAPI InitMenu (
  1139.     HWND    hWnd)
  1140. {
  1141.     HMENU hMenu = GetMenu (hWnd);
  1143.     /* if child process exists enable options */
  1144.     EnableMenuItem (hMenu,
  1145.     IDM_PROCESSREWALK,
  1146.     MF_BYCOMMAND | ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1147.     EnableMenuItem (hMenu,
  1148.     IDM_PROCESSUNLOAD,
  1149.     MF_BYCOMMAND | ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1151.     /* check appropriate sort menuitem */
  1152.     CheckMenuItem (hMenu, nSortType, MF_CHECKED);
  1154.     /* check view as bytes/pages menuitems */
  1155.     CheckMenuItem (hMenu, IDM_OPTBYTES, bNumbersAsBytes ? MF_CHECKED : MF_UNCHECKED);
  1156.     CheckMenuItem (hMenu, IDM_OPTPAGES, bNumbersAsBytes ? MF_UNCHECKED : MF_CHECKED);
  1158.     /* enable process and selection stat windows only when child process exists */
  1159.     EnableMenuItem (hMenu,
  1160.     IDM_VIEWPROSTAT,
  1161.     MF_BYCOMMAND | ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1162.     EnableMenuItem (hMenu,
  1163.     IDM_VIEWSYSSTAT,
  1164.     MF_BYCOMMAND | ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1166.     /* check all appropriate view menuitem */
  1167.     CheckMenuItem (hMenu,
  1168.    IDM_VIEWSYSSTAT,
  1169.    IsWindow (hWndSysStat) ? MF_CHECKED : MF_UNCHECKED);
  1170.     CheckMenuItem (hMenu,
  1171.    IDM_VIEWPROSTAT,
  1172.    IsWindow (hWndProStat) ? MF_CHECKED : MF_UNCHECKED);
  1174.     /* if child process exists */
  1175.     if (lpChildProcess != NULL)
  1176. {
  1177. /* child process is active */
  1178. if (lpChildProcess->bActive)
  1179.     {
  1180.     EnableMenuItem (hMenu, IDM_PROCESSRESUME, MF_GRAYED);
  1181.     EnableMenuItem (hMenu, IDM_PROCESSSUSPEND, MF_ENABLED);
  1182.     }
  1184. else
  1185.     {
  1186.     EnableMenuItem (hMenu, IDM_PROCESSSUSPEND, MF_GRAYED);
  1187.     EnableMenuItem (hMenu, IDM_PROCESSRESUME, MF_ENABLED);
  1188.     }
  1189. }
  1191.     /* diasble both menuitems */
  1192.     else
  1193. {
  1194. EnableMenuItem (hMenu, IDM_PROCESSSUSPEND, MF_GRAYED);
  1195. EnableMenuItem (hMenu, IDM_PROCESSRESUME, MF_GRAYED);
  1196. }
  1198.     /* sort only when process exists */
  1199.     EnableMenuItem (hMenu,
  1200.     IDM_SORTADDRESS,
  1201.     ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1202.     EnableMenuItem (hMenu,
  1203.     IDM_SORTSTATE,
  1204.     ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1205.     EnableMenuItem (hMenu,
  1206.     IDM_SORTPROTECTION,
  1207.     ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1208.     EnableMenuItem (hMenu,
  1209.     IDM_SORTSIZE,
  1210.     ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1211.     EnableMenuItem (hMenu,
  1212.     IDM_SORTBASEADDRESS,
  1213.     ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1215.     /* if child process & selection, and selection is committed memory */
  1216.     if (lpChildProcess != NULL &&
  1217. ViewableMemorySelection (hWnd))
  1218. EnableMenuItem (hMenu, IDM_VIEWMEMORY, MF_ENABLED);
  1219.     else
  1220. EnableMenuItem (hMenu, IDM_VIEWMEMORY, MF_GRAYED);
  1222. /* View address if child process */
  1223. EnableMenuItem (hMenu,
  1224. IDM_VIEWADDRESS,
  1225.     ((lpChildProcess != NULL) ? MF_ENABLED : MF_GRAYED));
  1228. }
  1233. int WINAPI MakeVMQString (
  1234.     int    nItem,
  1235.     char   *lpszMem)
  1236. {
  1237.     char   szState[10], szProtection[3];
  1238.     LPVMOBJECT   lpVMObject;
  1239.     int           nLen;
  1240.     int           nBaseAddr;
  1241.     int           nRegionSize;
  1242.     int           nAllocBase;
  1243.     LPSTR         lpszFormat;
  1245.     /* lookup object offset in array index */
  1246.     lpVMObject = ((VMOBJECT *)lpWalkerList)+Objects[nItem];
  1249.     /* determine state of memory object */
  1250.     if (lpVMObject->mbi.State & MEM_COMMIT)
  1251. strcpy (szState, "Commit ");
  1252.     else if (lpVMObject->mbi.State & MEM_RESERVE)
  1253. strcpy (szState, "Reserve");
  1254.     else
  1255. strcpy (szState, "Free   ");
  1257.     /* determine protection of memory */
  1258.     if (lpVMObject->mbi.Protect & PAGE_READWRITE)
  1259. strcpy (szProtection, "RW");
  1260.     else if (lpVMObject->mbi.Protect & PAGE_READONLY)
  1261. strcpy (szProtection, "RO");
  1262.     else
  1263. strcpy (szProtection, "NA");
  1265.     lpszFormat = szFormat;
  1266.     nBaseAddr = (int)(lpVMObject->mbi.BaseAddress);
  1267.     nRegionSize = lpVMObject->mbi.RegionSize;
  1268.     nAllocBase = (int)(lpVMObject->mbi.AllocationBase);
  1270.     if (!bNumbersAsBytes)
  1271.        {
  1272.        nBaseAddr /= PAGESIZE;
  1273.        nRegionSize /= PAGESIZE;
  1274.        nAllocBase /= PAGESIZE;
  1275.        lpszFormat = szFormatPages;
  1276.        }
  1278.     /* create list object */
  1279.     wsprintf(lpszMem,
  1280.      lpszFormat,
  1281.      nBaseAddr,
  1282.      szState,
  1283.      szProtection,
  1284.      nRegionSize,
  1285.      nAllocBase,
  1286.      lpVMObject->szObjType,
  1287.      lpVMObject->szSection,
  1288.              lpVMObject->szModule);
  1290.     /* return length of resulting string */
  1291.     nLen = strlen (lpszMem);
  1293.     // convert the ~ separators to  for the benefit of
  1294.     // TextOutFields
  1295.     //
  1296.     while (*lpszMem)
  1297.        {
  1298.        if (*lpszMem == '~') {
  1299.            *lpszMem = 0;
  1300.            // CharNext() returns the same pointer, if 'lpszMem' points ''.
  1301.            // So, we must not call CharNext() in this case.
  1302.            ++lpszMem;
  1303.        } else {
  1304.            lpszMem = CharNext(lpszMem);
  1305.        }
  1306.        }
  1308.     return nLen;
  1309. }
  1313. static void TextOutFields (
  1314.    HDC    hDC,
  1315.    int    x,
  1316.    LPRECT lprc,
  1317.    LPSTR  lpszItems)
  1318.    {
  1319.    int eto = ETO_CLIPPED | ETO_OPAQUE;
  1320.    int ii = 0;
  1321.    PSTR psz = lpszItems;
  1322.    int nLen;
  1324.    // copy fields until we get one of zero size.
  1325.    //
  1326.    do {
  1327.       SetTextAlign (hDC, taColumns[ii]);
  1329.       ExtTextOut(hDC,
  1330.                  lprc->left + (xColumns[ii] * sChar0.cx) + x,
  1331.                  lprc->top,
  1332.                  eto,
  1333.                  lprc,
  1334.                  psz,
  1335.                  nLen = strlen(psz),
  1336.                  0L);
  1338.       psz += (nLen + 1);
  1339.       eto = ETO_CLIPPED;
  1340.       ++ii;
  1341.       } while (nLen);
  1342.    }
  1346. void WINAPI DrawListItem(
  1347.     DRAWITEMSTRUCT *lpItem)
  1348. {
  1349.     DWORD dwBkColor=0xffffffff, dwTextColor=0xffffffff;
  1350.     char  szListItem[200];
  1351.     int   nLen;
  1353.     /* Make sure it is the list box with a valid item ID */
  1354.     if (lpItem->CtlType != ODT_LISTBOX ||
  1355. lpItem->CtlID != IDC_LISTBOX)
  1356.         return;
  1358.     if (lpItem->itemAction & (ODA_DRAWENTIRE | ODA_SELECT))
  1359. {
  1360.         /* Alter the bk and text color for selected items */
  1361. if (lpItem->itemState & ODS_SELECTED)
  1362.     {
  1363.     dwBkColor = SetBkColor (lpItem->hDC, GetSysColor(COLOR_HIGHLIGHT));
  1364.     dwTextColor = SetTextColor (lpItem->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
  1365.     }
  1367. /* change TextColor for new entries too */
  1368. else if ((((LPVMOBJECT)lpWalkerList)+Objects[lpItem->itemData])->bNew)
  1369.     {
  1370.     dwBkColor = SetBkColor (lpItem->hDC, GetSysColor(COLOR_HIGHLIGHT));
  1371.     dwTextColor = SetTextColor (lpItem->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
  1372.     }
  1374. /* make listbox string from virtual memory object */
  1375. nLen = MakeVMQString (lpItem->itemData, szListItem);
  1376.         TextOutFields (lpItem->hDC, 6, &lpItem->rcItem, szListItem);
  1378. /* Restore previous bk and text color if necessary */
  1379. if (dwBkColor != 0xffffffff)
  1380.             SetBkColor(lpItem->hDC, dwBkColor);
  1381. if (dwTextColor != 0xffffffff)
  1382.     SetTextColor(lpItem->hDC, dwTextColor);
  1384.         if (lpItem->itemState & ODS_FOCUS)
  1385.     lpItem->itemAction |= ODA_FOCUS;
  1387. }
  1389.     if (lpItem->itemAction & ODA_FOCUS)
  1390.         DrawFocusRect(lpItem->hDC, &lpItem->rcItem);
  1391. }
  1395. /* perform bubble sort on indexes to virtual memory objects as stored in
  1396.    ownerdraw listbox do not actually sort the objects, just the indexes  */
  1397. void  WINAPI SortList (
  1398.     HWND    hList,
  1399.     int     nSort)
  1400. {
  1401.     int    nItems = SendMessage (hList, LB_GETCOUNT, 0, 0);
  1402.     int    i, j, t;
  1403.     LPVMOBJECT   lpVMO = (LPVMOBJECT)lpWalkerList;
  1405.     /* loop through all items in list box */
  1406.     for (i=0; i<nItems-1; i++)
  1407. for (j=i+1; j<nItems; j++)
  1408.     {
  1409.     /* compare on sort order */
  1410.     switch (nSort)
  1411. {
  1412. case IDM_SORTADDRESS:
  1413.     if (lpVMO[Objects[i]].mbi.BaseAddress > lpVMO[Objects[j]].mbi.BaseAddress)
  1414. {
  1415. /* swap */
  1416. t = Objects[j];
  1417. Objects[j] = Objects[i];
  1418. Objects[i] = t;
  1419. }
  1420.     break;
  1422. case IDM_SORTSTATE:
  1423.     if ((lpVMO[Objects[i]].mbi.State > lpVMO[Objects[j]].mbi.State) ||
  1424. (lpVMO[Objects[i]].mbi.State == lpVMO[Objects[j]].mbi.State &&
  1425.  lpVMO[Objects[i]].mbi.BaseAddress > lpVMO[Objects[j]].mbi.BaseAddress))
  1426. {
  1427. /* swap */
  1428. t = Objects[j];
  1429. Objects[j] = Objects[i];
  1430. Objects[i] = t;
  1431. }
  1432.     break;
  1434. case IDM_SORTPROTECTION:
  1435.     if ((lpVMO[Objects[i]].mbi.Protect > lpVMO[Objects[j]].mbi.Protect) ||
  1436. (lpVMO[Objects[i]].mbi.Protect == lpVMO[Objects[j]].mbi.Protect &&
  1437.  lpVMO[Objects[i]].mbi.BaseAddress > lpVMO[Objects[j]].mbi.BaseAddress))
  1438. {
  1439. /* swap */
  1440. t = Objects[j];
  1441. Objects[j] = Objects[i];
  1442. Objects[i] = t;
  1443. }
  1444.     break;
  1446. case IDM_SORTSIZE:
  1447.     if ((lpVMO[Objects[i]].mbi.RegionSize > lpVMO[Objects[j]].mbi.RegionSize) ||
  1448. (lpVMO[Objects[i]].mbi.RegionSize == lpVMO[Objects[j]].mbi.RegionSize &&
  1449.  lpVMO[Objects[i]].mbi.BaseAddress > lpVMO[Objects[j]].mbi.BaseAddress))
  1450. {
  1451. /* swap */
  1452. t = Objects[j];
  1453. Objects[j] = Objects[i];
  1454. Objects[i] = t;
  1455. }
  1456.     break;
  1458. case IDM_SORTBASEADDRESS:
  1459.     if ((lpVMO[Objects[i]].mbi.AllocationBase > lpVMO[Objects[j]].mbi.AllocationBase) ||
  1460. (lpVMO[Objects[i]].mbi.AllocationBase == lpVMO[Objects[j]].mbi.AllocationBase &&
  1461.  lpVMO[Objects[i]].mbi.BaseAddress > lpVMO[Objects[j]].mbi.BaseAddress))
  1462. {
  1463. /* swap */
  1464. t = Objects[j];
  1465. Objects[j] = Objects[i];
  1466. Objects[i] = t;
  1467. }
  1468.     break;
  1469. }
  1470.     }
  1471. }
  1476. /* get free disk space on all fixed drives */
  1477. BOOL   WINAPI GetFreeDiskSpace (
  1478.     LPDWORD    lpdwTotalSpace,
  1479.     LPDWORD    lpdwFreeSpace)
  1480. {
  1481.     DWORD    dwBytesPerSector, dwSectorsPerCluster, dwFreeClusters, dwTotalClusters;
  1482.     DWORD    dwDriveMask = GetLogicalDrives();
  1483.     int      i;
  1484.     char     szDir[4];
  1486.     *lpdwTotalSpace = 0;
  1487.     *lpdwFreeSpace = 0;
  1488.     szDir[1] = TEXT(':');
  1489.     szDir[2] = TEXT('\');
  1490.     szDir[3] = 0;
  1492.     /* enumerate all logical, fixed drives */
  1493.     for (i = 0; i < MAX_DRIVES; dwDriveMask >>= 1, i++)
  1494. {
  1495. /* if logical drive exists */
  1496. if (dwDriveMask & 0x01)
  1497.     {
  1498.     szDir[0] = TEXT('A') + i;
  1500.     /* if it is a fixed drive */
  1501.     if (GetDriveType(szDir) == DRIVE_FIXED)
  1502. {
  1503. /* determine free space and total capacity */
  1504. GetDiskFreeSpace (szDir,
  1505.   &dwSectorsPerCluster,
  1506.   &dwBytesPerSector,
  1507.   &dwFreeClusters,
  1508.   &dwTotalClusters);
  1510. *lpdwTotalSpace += dwTotalClusters * dwSectorsPerCluster * dwBytesPerSector;
  1511. *lpdwFreeSpace += dwFreeClusters * dwSectorsPerCluster * dwBytesPerSector;
  1512. }
  1513.     }
  1514. }
  1516.     return (*lpdwTotalSpace || *lpdwFreeSpace);
  1517. }
  1521. /* generic message notification */
  1522. int WINAPI NotifyUser (
  1523.     HWND    hWndParent,
  1524.     int     nTitle,
  1525.     int     nError,
  1526.     char    *lpszAppend,
  1527.     UINT    uFlags)
  1528. {
  1529.     char    szError[MAX_PATH];
  1530.     char    szTitle[MAX_PATH];
  1532.     LoadString (GetModuleHandle (NULL), nTitle, szTitle, MAX_PATH);
  1533.     LoadString (GetModuleHandle (NULL), nError, szError, MAX_PATH);
  1535.     if (lpszAppend != NULL && *lpszAppend != 0)
  1536. strcat (szError, lpszAppend);
  1538.     if (!uFlags)
  1539. uFlags = MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND;
  1541.     /* return message box response */
  1542.     return (MessageBox (hWndParent, szError, szTitle, uFlags));
  1543. }
  1548. void   WINAPI ReportError (
  1549.     int     nIDS_CAPTION)
  1550. {
  1551.     char    *lpszError;
  1552.     char    szText[MAX_PATH];
  1554.     /* get formatted error message from system */
  1555.     if (!FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  1556. NULL,
  1557. GetLastError (),
  1558. MAKELONG (MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), 0),
  1559. (LPTSTR)&lpszError,
  1560. 0,
  1561. NULL))
  1562. return;
  1564.     /* if resource string provided, load caption string */
  1565.     if (nIDS_CAPTION)
  1566. LoadString (GetModuleHandle (NULL), nIDS_CAPTION, szText, MAX_PATH);
  1567.     else
  1568. strcpy (szText, "Error");
  1570.     MessageBox (NULL,
  1571. lpszError,
  1572. szText,
  1573. MB_ICONSTOP | MB_OK | MB_TASKMODAL | MB_SETFOREGROUND);
  1574. }
  1580. BOOL WINAPI ViewableMemorySelection (
  1581.     HWND    hWnd)
  1582. {
  1583.     HWND   hList = GetDlgItem (hWnd, IDC_LISTBOX);
  1584.     int    iCaret = SendMessage (hList, LB_GETCARETINDEX, 0, 0);
  1585.     int    iAnchor = SendMessage (hList, LB_GETANCHORINDEX, 0, 0);
  1587.     if (iCaret > -1 &&
  1588. iAnchor > -1 &&
  1589. SendMessage (hList, LB_GETSEL, iCaret, 0) &&
  1590. CommittedMemoryRange (iCaret,
  1591.       iAnchor,
  1592.       (LPVMOBJECT)lpWalkerList,
  1593.       Objects))
  1594. return TRUE;
  1595.     else
  1596. return FALSE;
  1597. }
  1602. BOOL WINAPI InitDlgProc (
  1603.     HWND      hDlg,
  1604.     UINT      uMsg,
  1605.     WPARAM    wParam,
  1606.     LPARAM    lParam)
  1607. {
  1608.     switch (uMsg)
  1609. {
  1610. case WM_INITDIALOG:
  1611.     *(HANDLE *)lParam = hDlg;
  1612.     break;
  1614. case WM_CLOSE:
  1615. case UM_ENDDIALOG:
  1616.     EndDialog (hDlg, TRUE);
  1617.     break;
  1619. case WM_COMMAND:
  1620.     if (LOWORD (wParam) == IDCANCEL ||
  1621. LOWORD (wParam) == IDOK)
  1622. EndDialog (hDlg, TRUE);
  1623.     break;
  1625. default:
  1626.     return FALSE;
  1627. }
  1629.     return TRUE;
  1630. }