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