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

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

Windows编程

开发平台：

Visual C++

PDEBUG.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. ******************************************************************************/
  12. #include "pwalk.h"
  13. #include <memory.h>
  16. /* module globals */
  17. LPVOID   PMAAddress;
  18. LPVOID   PMABuffer;
  19. DWORD   PMASize;
  20. extern   char   szCurPath[MAX_PATH];
  23. /* local debug functions */
  24. BOOL   WINAPI DebugEventThread (DBGPROCESS *);
  25. BOOL   WINAPI CreateDebugEvents (LPHANDLE);
  26. void   WINAPI AddThreadNode (DBGPROCESS *, DWORD, HANDLE, int, LPTHREAD_START_ROUTINE, HANDLE);
  27. int    WINAPI HandleBreakPoint(DBGPROCESS *, DWORD);
  28. void   WINAPI RemoveThreadNode (DBGPROCESS *, DWORD);
  29. void   WINAPI AddDllNode (DBGPROCESS *, LOAD_DLL_DEBUG_INFO *);
  30. void   WINAPI RemoveDllNode (DBGPROCESS *, LOAD_DLL_DEBUG_INFO *);
  31. void   WINAPI SuspendDebuggeeProcess (DBGPROCESS *);
  32. void   WINAPI ResumeDebuggeeProcess (DBGPROCESS *);
  33. void   WINAPI NameObjects (HANDLE, LPVOID, LPVMOBJECT, int, char *, char *);
  34. BOOL   WINAPI VMCompare (LPVMOBJECT, LPVMOBJECT);
  35. BOOL   WINAPI InterruptThread_HookProcess (DBGPROCESS *, LPPROCESS_STATE);
  36. void   WINAPI ResetInterruptedThread (DBGPROCESS *, LPPROCESS_STATE);
  37. void   WINAPI RecordException (DBGPROCESS *, DEBUG_EVENT *);
  38. HANDLE WINAPI FindThreadHandle (DBGPROCESS *, DWORD);
  42. /* start debug thread, and return event active handle */
  43. DBGPROCESS* WINAPI StartChildProcess (
  44.     HWND hWnd,
  45.     char *lpszModule,
  46.     LPHANDLE lpDbgEvents)
  47. {
  48.     DWORD   TID;
  49.     HANDLE   hDebugHeap;
  50.     DBGPROCESS   *lpDbgProcess;
  51.     int    i;
  53.     /* create unique debug events using debuggee process ID */
  54.     if (!CreateDebugEvents (lpDbgEvents))
  55. return NULL;
  57.     /* create serialized heap of dynamic size */
  58.     if (!(hDebugHeap = HeapCreate (0, sizeof (DBGPROCESS) + sizeof (DBGTHREAD), 0)))
  59. {
  60. /* close all event handles */
  61. for (i=0; i<nDEBUGEVENTS; i++)
  62.     CloseHandle (lpDbgEvents[i]);
  64. return NULL;
  65. }
  67.     /* allocate and initialize debug heap structure */
  68.     lpDbgProcess = (DBGPROCESS *)HeapAlloc (hDebugHeap, 0, sizeof (DBGPROCESS));
  69.     lpDbgProcess->hDbgHeap = hDebugHeap;
  70.     strcpy (lpDbgProcess->szModule, lpszModule);
  71.     lpDbgProcess->hWnd = hWnd;
  72.     lpDbgProcess->lpThreads = NULL;
  73.     lpDbgProcess->lpSection = NULL;
  74.     lpDbgProcess->lpERs = NULL;
  76.     /* create debug thread */
  77.     if (!(CreateThread ((LPSECURITY_ATTRIBUTES)NULL,
  78. 4096,
  79. (LPTHREAD_START_ROUTINE)DebugEventThread,
  80. (LPVOID)lpDbgProcess,
  81. 0,
  82. &TID)))
  83. return NULL;
  85.     /* wait 15 seconds for debugger to complete initialization, else error */
  86.     if (WAIT_TIMEOUT == WaitForSingleObject (lpDbgEvents[ACKNOWLEDGE], 15000))
  87. {
  88. HeapDestroy (lpDbgProcess->hDbgHeap);
  90. /* close all event handles */
  91. for (i=0; i<nDEBUGEVENTS; i++)
  92.     CloseHandle (lpDbgEvents[i]);
  94. return NULL;
  95. }
  97.     /* reset acknowledge event */
  98.     ResetEvent (lpDbgEvents[ACKNOWLEDGE]);
  100.     /* successfull thread and event start */
  101.     return lpDbgProcess;
  102. }
  107. /* function notifies debug thread to terminate, frees handles, and destroys heap */
  108. void   WINAPI CloseChildProcess (
  109.     DBGPROCESS *lpDbgProcess,
  110.     LPHANDLE   lpDbgEvents)
  111. {
  112.     int   i;
  113.     DBGTHREAD  *pNode = lpDbgProcess->lpThreads;
  115.     /* set close event for debug thread and wait for acknowledge */
  116.     SetEvent (lpDbgEvents[CLOSEDEBUGGER]);
  117.     WaitForSingleObject (lpDbgEvents[ACKNOWLEDGE], INFINITE);
  119.     /* close all event handles */
  120.     for (i=0; i<nDEBUGEVENTS; i++)
  121. CloseHandle (lpDbgEvents[i]);
  123.     /* close all thread handles in the list */
  124.     while (pNode != NULL)
  125. {
  126. RemoveThreadNode (lpDbgProcess, pNode->dwThreadID);
  127. pNode = lpDbgProcess->lpThreads;
  128. }
  130.     /* destroy the debug heap */
  131.     HeapDestroy (lpDbgProcess->hDbgHeap);
  132. }
  137. /* local function creates debug event objects for thread synchronization */
  138. BOOL WINAPI CreateDebugEvents (
  139.     LPHANDLE lpDbgEvents)
  140. {
  141.     char    szEvent[MAX_PATH];
  144.     LoadString (GetModuleHandle (NULL), IDS_DBGEVNTACTIVE, szEvent, sizeof (szEvent));
  145.     if (!(lpDbgEvents[DEBUGACTIVE] = CreateEvent ((LPSECURITY_ATTRIBUTES)NULL,
  146.   TRUE,
  147.   TRUE,
  148.   szEvent)))
  149. return FALSE;
  151.     LoadString (GetModuleHandle (NULL), IDS_DBGEVNTCLOSE, szEvent, sizeof (szEvent));
  152.     if (!(lpDbgEvents[CLOSEDEBUGGER] = CreateEvent ((LPSECURITY_ATTRIBUTES)NULL,
  153.    TRUE,
  154.    FALSE,
  155.    szEvent)))
  156. {
  157. CloseHandle (lpDbgEvents[DEBUGACTIVE]);
  158. return FALSE;
  159. }
  161.     LoadString (GetModuleHandle (NULL), IDS_DBGEVNTSTOP, szEvent, sizeof (szEvent));
  162.     if (!(lpDbgEvents[SUSPENDDEBUGGER] = CreateEvent ((LPSECURITY_ATTRIBUTES)NULL,
  163.       TRUE,
  164.       FALSE,
  165.       szEvent)))
  166. {
  167. CloseHandle (lpDbgEvents[DEBUGACTIVE]);
  168. CloseHandle (lpDbgEvents[CLOSEDEBUGGER]);
  169. return FALSE;
  170. }
  172.     LoadString (GetModuleHandle (NULL), IDS_DBGEVNTSTART, szEvent, sizeof (szEvent));
  173.     if (!(lpDbgEvents[RESUMEDEBUGGER] = CreateEvent ((LPSECURITY_ATTRIBUTES)NULL,
  174.      TRUE,
  175.      FALSE,
  176.      szEvent)))
  177. {
  178. CloseHandle (lpDbgEvents[DEBUGACTIVE]);
  179. CloseHandle (lpDbgEvents[CLOSEDEBUGGER]);
  180. CloseHandle (lpDbgEvents[SUSPENDDEBUGGER]);
  181. return FALSE;
  182. }
  184.     LoadString (GetModuleHandle (NULL), IDS_DBGEVNTREAD, szEvent, sizeof (szEvent));
  185.     if (!(lpDbgEvents[READMEMORY] = CreateEvent ((LPSECURITY_ATTRIBUTES)NULL,
  186.  TRUE,
  187.  FALSE,
  188.  szEvent)))
  189. {
  190. CloseHandle (lpDbgEvents[DEBUGACTIVE]);
  191. CloseHandle (lpDbgEvents[CLOSEDEBUGGER]);
  192. CloseHandle (lpDbgEvents[SUSPENDDEBUGGER]);
  193. CloseHandle (lpDbgEvents[RESUMEDEBUGGER]);
  194. return FALSE;
  195. }
  197.     LoadString (GetModuleHandle (NULL), IDS_DBGEVNTWRITE, szEvent, sizeof (szEvent));
  198.     if (!(lpDbgEvents[WRITEMEMORY] = CreateEvent ((LPSECURITY_ATTRIBUTES)NULL,
  199.   TRUE,
  200.   FALSE,
  201.   szEvent)))
  202. {
  203. CloseHandle (lpDbgEvents[DEBUGACTIVE]);
  204. CloseHandle (lpDbgEvents[CLOSEDEBUGGER]);
  205. CloseHandle (lpDbgEvents[SUSPENDDEBUGGER]);
  206. CloseHandle (lpDbgEvents[RESUMEDEBUGGER]);
  207. CloseHandle (lpDbgEvents[READMEMORY]);
  208. return FALSE;
  209. }
  211.     LoadString (GetModuleHandle (NULL), IDS_DBGEVNTACK, szEvent, sizeof (szEvent));
  212.     if (!(lpDbgEvents[ACKNOWLEDGE] = CreateEvent ((LPSECURITY_ATTRIBUTES)NULL,
  213.   TRUE,
  214.   FALSE,
  215.   szEvent)))
  216. {
  217. CloseHandle (lpDbgEvents[DEBUGACTIVE]);
  218. CloseHandle (lpDbgEvents[CLOSEDEBUGGER]);
  219. CloseHandle (lpDbgEvents[SUSPENDDEBUGGER]);
  220. CloseHandle (lpDbgEvents[RESUMEDEBUGGER]);
  221. CloseHandle (lpDbgEvents[READMEMORY]);
  222. CloseHandle (lpDbgEvents[WRITEMEMORY]);
  223. return FALSE;
  224. }
  226.     /* success */
  227.     return TRUE;
  228. }
  234. /* main daddyo thread that is the debugger residing over a debuggee */
  235. BOOL WINAPI DebugEventThread (
  236.     DBGPROCESS   *lpDbgProcess)
  237. {
  238.     DEBUG_EVENT     de;
  239.     HANDLE    hDbgEvent[nDEBUGEVENTS];
  240.     STARTUPINFO     si;
  241.     PROCESS_INFORMATION    pi;
  242.     HANDLE    hChildProcess;
  243.     BOOL    bHooked, bUnHooked;
  244. //    PROCESS_STATE    ProcessState;
  247.     bHooked = FALSE;
  248.     bUnHooked = FALSE;
  250.     /* initialize process startup information */
  251.     si.cb        = sizeof (si);
  252.     si.lpReserved      = NULL;
  253.     si.lpDesktop       = NULL;
  254.     si.lpTitle        = NULL;
  255.     si.dwX        = 0;
  256.     si.dwY        = 0;
  257.     si.dwXSize        = 0;
  258.     si.dwYSize        = 0;
  259.     si.dwXCountChars   = 0;
  260.     si.dwYCountChars   = 0;
  261.     si.dwFillAttribute = 0;
  262.     si.dwFlags        = STARTF_FORCEONFEEDBACK | STARTF_USESHOWWINDOW;
  263.     si.wShowWindow     = SW_SHOWNORMAL;
  264.     si.cbReserved2     = 0;
  265.     si.lpReserved2     = NULL;
  267.     /* create debug process on module name */
  268.     if (!CreateProcess (lpDbgProcess->szModule,
  269. NULL,
  270. (LPSECURITY_ATTRIBUTES)NULL,
  271. (LPSECURITY_ATTRIBUTES)NULL,
  272. FALSE,
  273. DEBUG_PROCESS,
  274. NULL,
  275. NULL,
  276. (LPSTARTUPINFO)&si,
  277. (LPPROCESS_INFORMATION)&pi))
  278. {
  279. ReportError (IDS_ERRCREATEPROCESS);
  280. return FALSE;
  281. }
  282.     /* open process for all access */
  283.     if ((hChildProcess = OpenProcess (PROCESS_ALL_ACCESS,
  284.       FALSE,
  285.       pi.dwProcessId)) == NULL)
  286. {
  287. ReportError (IDS_ERROPENPROCESS);
  288. TerminateProcess (pi.hProcess, 0);
  289. return FALSE;
  290. }
  292.     /* store process info */
  293.     lpDbgProcess->hProcess = hChildProcess;
  294.     lpDbgProcess->dwPriority = GetPriorityClass (pi.hProcess);
  295.     lpDbgProcess->dwProcessID = pi.dwProcessId;
  296.     lpDbgProcess->bActive = TRUE;
  298.     /* close process and thread handles in pi structure */
  299.     CloseHandle (pi.hThread);
  300.     CloseHandle (pi.hProcess);
  302.     /* open debug events */
  303.     CreateDebugEvents (hDbgEvent);
  305.     /* signale completion of task */
  306.     SetEvent (hDbgEvent[ACKNOWLEDGE]);
  308.     /* start debug event loop */
  309.     while (TRUE)
  310. {
  311. int    nIndex;
  313. /* wait for debugger active */
  314. switch (nIndex = WaitForMultipleObjects (nDEBUGEVENTS, hDbgEvent, FALSE, INFINITE))
  315.     {
  316.     case CLOSEDEBUGGER:
  317. {
  318. int    i;
  320. /* terminate debuggee process */
  321. TerminateProcess (lpDbgProcess->hProcess, 0);
  322. CloseHandle (lpDbgProcess->hProcess);
  324. /* signal completion of task */
  325. SetEvent (hDbgEvent[ACKNOWLEDGE]);
  327. /* close all debug events */
  328. for (i=0; i<nDEBUGEVENTS; i++)
  329.     CloseHandle (hDbgEvent[i]);
  331. /* exit debugger now */
  332. return TRUE;
  333. }
  334. break;
  336.     case SUSPENDDEBUGGER:
  337. SuspendDebuggeeProcess (lpDbgProcess);
  338. ResetEvent (hDbgEvent[DEBUGACTIVE]);
  339. ResetEvent (hDbgEvent[SUSPENDDEBUGGER]);
  340. break;
  342.     case RESUMEDEBUGGER:
  343. ResumeDebuggeeProcess (lpDbgProcess);
  344. SetEvent (hDbgEvent[DEBUGACTIVE]);
  345. ResetEvent (hDbgEvent[RESUMEDEBUGGER]);
  346. break;
  348.     case READMEMORY:
  349. {
  350. MEMORY_BASIC_INFORMATION    mbi;
  351. DWORD     Protect = 0;
  353. /* reset event so we don't do repeat */
  354. ResetEvent (hDbgEvent [READMEMORY]);
  356. /* if not committed memory abort */
  357. if (!VirtualQueryEx (lpDbgProcess->hProcess,
  358.      PMAAddress,
  359.      &mbi,
  360.      sizeof (MEMORY_BASIC_INFORMATION)) ||
  361.     mbi.State != MEM_COMMIT)
  362.     {
  363.     PMASize = 0;
  364.     SetEvent (hDbgEvent [ACKNOWLEDGE]);
  365.     break;
  366.     }
  368. /* if guarded memory, change protection temporarily */
  369. if (!(mbi.Protect & PAGE_READONLY) &&
  370.     !(mbi.Protect & PAGE_READWRITE))
  371.     VirtualProtectEx (lpDbgProcess->hProcess,
  372.       PMAAddress,
  373.       PMASize,
  374.       PAGE_READONLY,
  375.       &Protect);
  377. if (!ReadProcessMemory (lpDbgProcess->hProcess,
  378. PMAAddress,
  379. PMABuffer,
  380. PMASize,
  381. NULL))
  382.     {
  383.     if (mbi.AllocationProtect != PAGE_READONLY &&
  384. mbi.AllocationProtect != PAGE_READWRITE)
  385. NotifyUser (NULL, IDS_ERROR, 0, "BaseProtect NOACCESS", 0);
  386.     else
  387. {
  388. ReportError (IDS_ERRREADPROCESSMEMORY);
  389. PMASize = 0;
  390. }
  391.     }
  393. /* reset protection if changed */
  394. if (Protect)
  395.     VirtualProtectEx (lpDbgProcess->hProcess,
  396.       PMAAddress,
  397.       PMASize,
  398.       Protect,
  399.       &Protect);
  401. /* acknowledge success */
  402. SetEvent (hDbgEvent [ACKNOWLEDGE]);
  403. }
  404. break;
  406.     case WRITEMEMORY:
  407. if (!WriteProcessMemory (lpDbgProcess->hProcess,
  408.  PMAAddress,
  409.  PMABuffer,
  410.  PMASize,
  411.  NULL))
  412.     {
  413.     ReportError (IDS_ERRWRITEPROCESSMEMORY);
  414.     PMASize = 0;
  415.     }
  417. ResetEvent (hDbgEvent [WRITEMEMORY]);
  418. SetEvent (hDbgEvent [ACKNOWLEDGE]);
  419. break;
  421.     case DEBUGACTIVE:
  422. /* if debug active */
  423. if ((WaitForDebugEvent (&de, (DWORD)100)))
  424.     {
  425.     if (de.dwProcessId == lpDbgProcess->dwProcessID)
  426. {
  427. switch (de.dwDebugEventCode)
  428.     {
  429.     case EXIT_PROCESS_DEBUG_EVENT:
  430. SetStatusText (lpDbgProcess->hWnd, IDS_EXITPROCESS, 0);
  432. /* uninitialize probe dll */
  433. ResetProbe ();
  435. /* process is going away so notify main window */
  436. SendNotifyMessage (lpDbgProcess->hWnd,
  437.    WM_COMMAND,
  438.    IDM_PROCESSUNLOAD,
  439.    0);
  440. break;
  442.     case LOAD_DLL_DEBUG_EVENT:
  443. SetStatusText (lpDbgProcess->hWnd, IDS_LOADDLL, 0);
  444. AddDllNode (lpDbgProcess,
  445.     (LOAD_DLL_DEBUG_INFO *)&(de.u.LoadDll));
  446. break;
  448.     case UNLOAD_DLL_DEBUG_EVENT:
  449. SetStatusText (lpDbgProcess->hWnd, IDS_UNLOADDLL, 0);
  450. RemoveDllNode (lpDbgProcess,
  451.        (LOAD_DLL_DEBUG_INFO *)&(de.u.LoadDll));
  452. break;
  454.     case CREATE_PROCESS_DEBUG_EVENT:
  455. SetStatusText (lpDbgProcess->hWnd, IDS_CREATEPROCESS, 0);
  456. /* add first thread to linked list of dbg structures */
  457. AddThreadNode (lpDbgProcess,
  458. de.dwThreadId,
  459. de.u.CreateProcessInfo.hThread,
  460. GetThreadPriority (de.u.CreateProcessInfo.hThread),
  461. de.u.CreateProcessInfo.lpStartAddress,
  462. de.u.CreateProcessInfo.hFile);
  463. lpDbgProcess->hFile = de.u.CreateProcessInfo.hFile;
  464. lpDbgProcess->lpImage = de.u.CreateProcessInfo.lpBaseOfImage;
  465. lpDbgProcess->dwDbgInfoOffset = de.u.CreateProcessInfo.dwDebugInfoFileOffset;
  466. lpDbgProcess->nDbgInfoSize = de.u.CreateProcessInfo.nDebugInfoSize;
  467. break;
  469.     case CREATE_THREAD_DEBUG_EVENT:
  470. SetStatusText (lpDbgProcess->hWnd, IDS_CREATETHREAD, 0);
  471. /* add thread to linked list of dbg structures */
  472. AddThreadNode (lpDbgProcess,
  473.  de.dwThreadId,
  474.  de.u.CreateThread.hThread,
  475.  GetThreadPriority (de.u.CreateThread.hThread),
  476.  de.u.CreateThread.lpStartAddress,
  477.  NULL);
  478. break;
  480.     case EXIT_THREAD_DEBUG_EVENT:
  481. SetStatusText (lpDbgProcess->hWnd, IDS_EXITTHREAD, 0);
  482. /* remove thread record */
  483. RemoveThreadNode (lpDbgProcess,
  484.     de.dwThreadId);
  485. break;
  487.     case EXCEPTION_DEBUG_EVENT:
  488. switch (de.u.Exception.ExceptionRecord.ExceptionCode)
  489.     {
  490.     case EXCEPTION_BREAKPOINT:
  492. HandleBreakPoint(lpDbgProcess, de.dwThreadId);
  493. SetStatusText (lpDbgProcess->hWnd,
  494.        IDS_BREAKPOINTEXCEPTION,
  495.        RGB (0, 0xff, 0));
  497. /* post message to get ball rolling in main thread */
  498. PostMessage (lpDbgProcess->hWnd,
  499.  WM_COMMAND,
  500.  IDM_PROCESSREWALK,
  501.  0);
  502. break;
  504.     case EXCEPTION_ACCESS_VIOLATION:
  505. /* record exception information */
  506. SetStatusText (lpDbgProcess->hWnd,
  507.        IDS_ACCESSVIOLATIONEXCEPTION,
  508.        RGB (0xff, 0, 0));
  509. RecordException (lpDbgProcess, &de);
  510. break;
  512.     default:
  513. SetStatusText (lpDbgProcess->hWnd,
  514.        IDS_UNHANDLEDEXCEPTION,
  515.        RGB (0xff, 0, 0));
  516. RecordException (lpDbgProcess, &de);
  517. break;
  518.     }
  519. break;
  521.     case RIP_EVENT:
  522. SetStatusText (lpDbgProcess->hWnd,
  523.        IDS_RIPEVENT,
  524.        RGB (0, 0xff, 0));
  525. break;
  527.     case OUTPUT_DEBUG_STRING_EVENT:
  528. SetStatusText (lpDbgProcess->hWnd,
  529.        IDS_OUTPUTDEBUGSTRING,
  530.        RGB (0, 0xff, 0));
  531. break;
  533.     default:
  534. break;
  535.     }
  536. }
  538.             if(de.u.Exception.ExceptionRecord.ExceptionCode != EXCEPTION_BREAKPOINT)
  539.         ContinueDebugEvent (de.dwProcessId, de.dwThreadId, DBG_EXCEPTION_NOT_HANDLED);
  540.             else
  541.         ContinueDebugEvent (de.dwProcessId, de.dwThreadId, DBG_CONTINUE);
  542.     }
  543. break;
  544.     }
  546. }
  548.     return TRUE;
  549. }
  554. void WINAPI SuspendDebuggeeProcess (
  555.     DBGPROCESS   *lppr)
  556. {
  557.     DBGTHREAD  *lpth = (DBGTHREAD *)lppr->lpThreads;
  559.     while (lpth)
  560. {
  561. SuspendThread (lpth->hThread);
  562. lpth = (DBGTHREAD *)lpth->Next;
  563. }
  565.     /* inform user via status bar */
  566.     SetStatusText (lppr->hWnd, IDS_PROCESSSUSPENDED, RGB (0xff, 0, 0));
  567.     lppr->bActive = FALSE;
  568. }
  573. void WINAPI ResumeDebuggeeProcess (
  574.     DBGPROCESS   *lppr)
  575. {
  576.     DBGTHREAD  *lpth = (DBGTHREAD *)lppr->lpThreads;
  578.     while (lpth)
  579. {
  580. ResumeThread (lpth->hThread);
  581. lpth = (DBGTHREAD *)lpth->Next;
  582. }
  584.     /* inform user via status bar */
  585.     SetStatusText (lppr->hWnd, IDS_PROCESSRESUMED, RGB (0, 0xff, 0));
  586.     lppr->bActive = TRUE;
  587. }
  592. void WINAPI AddThreadNode (
  593.     DBGPROCESS       *lppr,
  594.     DWORD       dwThreadID,
  595.     HANDLE       hThread,
  596.     int        nPriority,
  597.     LPTHREAD_START_ROUTINE    lpStart,
  598.     HANDLE       hFile)
  599. {
  600.     DBGTHREAD  *lpth;
  601.     DBGTHREAD  *pNode = lppr->lpThreads;
  603.     /* allocate thread node off heap */
  604.     lpth = (DBGTHREAD *)HeapAlloc (lppr->hDbgHeap, 0, sizeof (DBGTHREAD));
  606.     /* initialize thread data */
  607.     lpth->lpStartAddress = lpStart;
  608.     lpth->nPriority = nPriority;
  609.     lpth->dwThreadID = dwThreadID;
  610.     lpth->hThread = hThread;
  611.     lpth->Next = NULL;
  613.     /* retieve section names for executable module if file handle passed */
  614.     if (hFile)
  615. {
  616. RetrieveModuleName (lppr->szModule, hFile);
  617. lppr->lpSection = NULL;
  618. RetrieveSectionNames (lppr->hDbgHeap, hFile, &(lppr->lpSection));
  619. }
  621.     /* set linked list pointers */
  622.     while (pNode && pNode->Next)
  623. pNode = (DBGTHREAD *)pNode->Next;
  625.     if (!pNode)
  626. lppr->lpThreads = lpth;
  627.     else
  628. (DBGTHREAD *)pNode->Next = lpth;
  629. }
  634. void WINAPI RemoveThreadNode (
  635.     DBGPROCESS   *lppr,
  636.     DWORD   dwThreadID)
  637. {
  638.     DBGTHREAD  *pNode = lppr->lpThreads;
  639.     DBGTHREAD  *lpth;
  641.     while (pNode->Next &&
  642.    ((DBGTHREAD *)(pNode->Next))->dwThreadID != dwThreadID)
  643. pNode = (DBGTHREAD *)pNode->Next;
  645.     if (pNode->Next)
  646. {
  647. lpth = (DBGTHREAD *)pNode->Next;
  648. pNode->Next = ((DBGTHREAD *)(pNode->Next))->Next;
  649. CloseHandle (lpth->hThread);
  650. HeapFree (lppr->hDbgHeap, 0, (LPSTR)lpth);
  651. }
  653.     else if (pNode->dwThreadID == dwThreadID)
  654. {
  655. lpth = pNode;
  656. lppr->lpThreads = NULL;
  657. CloseHandle (lpth->hThread);
  658. HeapFree (lppr->hDbgHeap, 0, (LPSTR)lpth);
  659. }
  660. }
  664. /* find a thread's handle based on thread ID */
  665. HANDLE WINAPI FindThreadHandle (
  666.     DBGPROCESS   *lppr,
  667.     DWORD   dwThreadId)
  668. {
  669.     DBGTHREAD  *pNode = lppr->lpThreads;
  671.     while (pNode != NULL)
  672. if (pNode->dwThreadID == dwThreadId)
  673.     return (pNode->hThread);
  674.     return NULL;
  675. }
  680. void WINAPI AddDllNode (
  681.     DBGPROCESS    *lppr,
  682.     LOAD_DLL_DEBUG_INFO    *lpdbgDll)
  683. {
  684.     DBGDLL    *lpdll;
  685.     DBGDLL    *pNode = lppr->lpDlls;
  687.     /* allocate Dll node off heap */
  688.     if ((lpdll = (DBGDLL *)HeapAlloc (lppr->hDbgHeap, 0, sizeof (DBGDLL))) == NULL)
  689. ReportError (IDS_ERRHEAPALLOC);
  691.     /* initialize Dll structure */
  692.     lpdll->hFile = lpdbgDll->hFile;
  693.     lpdll->lpBaseOfDll = lpdbgDll->lpBaseOfDll;
  694.     lpdll->dwDebugInfoFileOffset = lpdbgDll->dwDebugInfoFileOffset;
  695.     lpdll->nDebugInfoSize = lpdbgDll->nDebugInfoSize;
  696.     lpdll->fUnicode = lpdbgDll->fUnicode;
  697.     lpdll->Next = NULL;
  698.     lpdll->lpSection = NULL;
  700. RetrieveModuleName (lpdll->szImageName, lpdbgDll->hFile);
  702.     /* get section names for DLL */
  703.     RetrieveSectionNames (lppr->hDbgHeap, lpdbgDll->hFile, &(lpdll->lpSection));
  705.     /* set linked list pointers */
  706.     while (pNode && pNode->Next)
  707. pNode = (DBGDLL *)pNode->Next;
  709.     if (!pNode)
  710. lppr->lpDlls = lpdll;
  711.     else
  712. (DBGDLL *)pNode->Next = lpdll;
  713. }
  717. void WINAPI RemoveDllNode (
  718.     DBGPROCESS    *lppr,
  719.     LOAD_DLL_DEBUG_INFO    *lpdbgDll)
  720. {
  721.     DBGDLL   *pNode = lppr->lpDlls;
  722.     DBGDLL   *lpdll;
  723.     SECTIONINFO    *pSection, *pNext;
  725.     while (pNode->Next &&
  726.    ((DBGDLL *)(pNode->Next))->lpBaseOfDll != lpdbgDll->lpBaseOfDll)
  727. pNode = (DBGDLL *)pNode->Next;
  729.     if (pNode->Next)
  730. {
  731. lpdll = (DBGDLL *)pNode->Next;
  732. pNode->Next = ((DBGDLL *)(pNode->Next))->Next;
  734. pSection = pNext = lpdll->lpSection;
  735. while (pNext)
  736.     {
  737.     pNext = (SECTIONINFO *)pSection->Next;
  738.     HeapFree (lppr->hDbgHeap, 0, (LPSTR)pSection);
  739.     pSection = pNext;
  740.     }
  742. HeapFree (lppr->hDbgHeap, 0, (LPSTR)lpdll);
  743. }
  745.     else if (pNode->lpBaseOfDll == lpdbgDll->lpBaseOfDll)
  746. {
  747. lpdll = pNode;
  748. lppr->lpDlls = NULL;
  750. pSection = pNext = lpdll->lpSection;
  751. while (pNext)
  752.     {
  753.     pNext = (SECTIONINFO *)pSection->Next;
  754.     HeapFree (lppr->hDbgHeap, 0, (LPSTR)pSection);
  755.     pSection = pNext;
  756.     }
  758. HeapFree (lppr->hDbgHeap, 0, (LPSTR)lpdll);
  759. }
  760. }
  764. void WINAPI RecordException (
  765.     DBGPROCESS    *lppr,
  766.     DEBUG_EVENT    *de)
  767. {
  768.     DBGEXCEPTREC    *lper;
  769.     DBGEXCEPTREC    *per = lppr->lpERs;
  770.     HANDLE     hThread;
  771.     int      i;
  773.     /* allocate Dll node off heap */
  774.     if ((lper = (DBGEXCEPTREC *)HeapAlloc (lppr->hDbgHeap, 0, sizeof (DBGEXCEPTREC))) == NULL)
  775. ReportError (IDS_ERRHEAPALLOC);
  777.     /* initialize exception record structure */
  778.     lper->dwThreadId = de->dwThreadId;
  779.     lper->dwFirstChance = de->u.Exception.dwFirstChance;
  780.     lper->ExceptRecord.ExceptionCode = de->u.Exception.ExceptionRecord.ExceptionCode;
  781.     lper->ExceptRecord.ExceptionFlags = de->u.Exception.ExceptionRecord.ExceptionFlags;
  782.     lper->ExceptRecord.ExceptionRecord = NULL;
  783.     lper->ExceptRecord.ExceptionAddress = de->u.Exception.ExceptionRecord.ExceptionAddress;
  784.     lper->ExceptRecord.NumberParameters = de->u.Exception.ExceptionRecord.NumberParameters;
  785.     for (i=0; i<EXCEPTION_MAXIMUM_PARAMETERS; i++)
  786. lper->ExceptRecord.ExceptionInformation[i] =
  787.    de->u.Exception.ExceptionRecord.ExceptionInformation[i];
  789.     /* get exception thread handle */
  790.     hThread = FindThreadHandle (lppr, de->dwThreadId);
  791.     lper->Context.ContextFlags = CONTEXT_CONTROL;
  792.     GetThreadContext (hThread, &(lper->Context));
  794.     /* set linked list pointers */
  795.     while (per && per->Next)
  796. per = (DBGEXCEPTREC *)per->Next;
  797.     if (!per)
  798. lppr->lpERs = lper;
  799.     else
  800. (DBGEXCEPTREC *)per->Next = lper;
  801. }
  805. /*
  806.  * MIPS/ALPHA/PPC must increment the FIR/Iar on a breakpoint
  807.  * in order to fetch the next instruction
  808.  */
  810. int WINAPI HandleBreakPoint(
  811.     DBGPROCESS       *lppr,
  812.     DWORD       dwThreadID
  813.     )
  814. {
  815.     CONTEXT   ThreadContext;
  816.     DBGTHREAD *pNode = lppr->lpThreads;
  817.     HANDLE    hThread;
  819.     while (pNode && pNode->dwThreadID != dwThreadID)
  820. pNode = (DBGTHREAD *)pNode->Next;
  822.     if(!pNode)
  823. return(0);
  824.     else
  825. {
  826.         hThread = (HANDLE) pNode->hThread;
  828.         ThreadContext.ContextFlags = CONTEXT_CONTROL;
  829.         if (!GetThreadContext (hThread, &ThreadContext))
  830.     {
  831.     ReportError (IDS_ERRGETTHREADCONTEXT);
  832.             return(0);
  833.     }
  835. #ifdef _PPC_
  836.         ThreadContext.Iar += 4;
  837. #elif !defined _X86_
  838.         ThreadContext.Fir += 4;
  839. #endif
  841.         if (!SetThreadContext (hThread, &ThreadContext))
  842.     {
  843.     ReportError (IDS_ERRSETTHREADCONTEXT);
  844.     return (0);
  845.     }
  847. return (1);
  848. }
  849. }
  853. int   WINAPI WhereIsStack (
  854.     HANDLE   hThreadContext)
  855. {
  856.     CONTEXT ThreadContext;
  858.     ThreadContext.ContextFlags = CONTEXT_CONTROL;
  859.     if (!GetThreadContext (hThreadContext, &ThreadContext))
  860. ReportError (IDS_ERRGETTHREADCONTEXT);
  862. #ifdef _X86_
  863.     return ThreadContext.Esp;
  864. #elif defined (_PPC_)
  865.     return (int) ThreadContext.Gpr1;
  866. #else /* _MIPS_ */
  867.     return (int) ThreadContext.IntSp;
  868. #endif
  870. }
  874. /* function walks memory regions of process */
  875. int    WINAPI WalkProcess (
  876.     HANDLE    hChildProcess,
  877.     LPVOID    *lpWalk,
  878.     LPINT     *lpObjects)
  879. {
  880.     LPVMOBJECT   lpList;
  881.     LPVOID   lpMem = 0;
  882.     LPVOID   lpStack = 0;
  883.     int    nCnt, i;
  884.     SYSTEM_INFO   si;
  886.     /* if pointer exists, reset to no commit */
  887.     if (*lpWalk)
  888. {
  889. if (!VirtualFree (*lpWalk, 0, MEM_DECOMMIT))
  890.     ReportError (IDS_ERRVIRTUALFREE);
  891. }
  893.     /* else perform initial reserve */
  894.     else
  895. if ((*lpWalk = VirtualAlloc (NULL,
  896.      TOTALVMRESERVE,
  897.      MEM_RESERVE,
  898.      PAGE_NOACCESS)) == NULL)
  899.     ReportError (IDS_ERRVIRTUALALLOC);
  901.     /* initialize list pointer to beginning of walker list */
  902.     lpList = (LPVMOBJECT)*lpWalk;
  904.     /* Get maximum address range from system info */
  905.     GetSystemInfo(&si);
  907.     /* walk process addresses */
  908.     while (lpMem < si.lpMaximumApplicationAddress)
  909. {
  910. try  /* virtual memory exception handler automatically commits mem */
  911.     {
  912.     /* touch memory in VMOBJECT structure that exists after mbi field to trigger
  913.        access violation for a new page of memory.  Do this here since VirtualQueryEx
  914.        does not seem to generate exceptions, rather it just fails calls */
  915.     *lpList->szObjType = 0;
  916.     *lpList->szModule = 0;
  917.     *lpList->szSection = 0;
  918.     lpList->bNew = 0;
  920.     VirtualQueryEx (hChildProcess,
  921.     lpMem,
  922.     &(lpList->mbi),
  923.     sizeof (MEMORY_BASIC_INFORMATION));
  925.     /* increment lpMem to next region of memory */
  926.     lpMem = (LPVOID)((DWORD)lpList->mbi.BaseAddress +
  927.      (DWORD)lpList->mbi.RegionSize);
  929.     lpList++;
  930.     }
  932. except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION)
  933.     {
  934.     /* commit next page of walker list memory */
  935.     if (((int)lpList + 4096) < (int)*lpWalk + TOTALVMRESERVE)
  936. VirtualAlloc ((LPVOID)((int)lpList + sizeof (VMOBJECT)),
  937.       4096,
  938.       MEM_COMMIT,
  939.       PAGE_READWRITE);
  940.     else
  941. {
  942. NotifyUser (NULL,
  943.     IDS_ERROR,
  944.     IDS_NOTENOUGHMEM,
  945.     " reserved for Objects",
  946.     MB_OK);
  947. return 0;
  948. }
  949.     }
  950. }
  952.     /* allocate objects index array */
  953.     if (*lpObjects)
  954. LocalFree (*lpObjects);
  955.     nCnt = (((int)(LPVOID)lpList)-(int)*lpWalk)/sizeof (VMOBJECT);
  956.     *lpObjects = LocalAlloc (LPTR, nCnt * sizeof (int));
  957.     for (i=0; i<nCnt; i++)
  958. (*lpObjects)[i] = i;
  960.     /* return number of item in list */
  961.     return (nCnt);
  962. }
  967. void WINAPI AnalyzeProcess (
  968.     DBGPROCESS   *lpDbgProcess,
  969.     LPVMOBJECT   lpVMObject,
  970.     int    nObjects)
  971. {
  972.     DBGTHREAD *pTh = lpDbgProcess->lpThreads;
  973.     DBGDLL *pDll = lpDbgProcess->lpDlls;
  974.     int  nStack;
  975.     int  nThreadCnt = 0;
  976.     char szNum[10];
  977.     char szObjDesc[MAX_PATH];
  978.     SECTIONINFO   *pSection;
  979.     int  i;
  980.     MEMORY_BASIC_INFORMATION mbi;
  981.     LPPROBE lpProbe;
  984.     /* name default heap in process if available */
  985.     if (lpProbe = RetrieveProbeData ())
  986. {
  987. VirtualQueryEx (lpDbgProcess->hProcess, (PVOID)lpProbe->hDefHeap, &mbi, sizeof (mbi));
  989. /* ignore invalid regions with a base region of 0 */
  990. if (mbi.AllocationBase)
  991.     {
  992.     /* find all objects with same base region */
  993.     for (i=0; i<nObjects; i++)
  994. {
  995. if (lpVMObject[i].mbi.AllocationBase == mbi.AllocationBase)
  996.     {
  997.     strcpy (lpVMObject[i].szObjType, "heap");
  998.     strcpy (lpVMObject[i].szModule, "process default");
  999.     }
  1000. }
  1001.     }
  1002. }
  1004.     /* name stack object for each thread in process */
  1005.     while (pTh != NULL)
  1006. {
  1007. /* get stack location for thread */
  1008. nStack = WhereIsStack (pTh->hThread);
  1010. strcpy (szObjDesc, "Thread ");
  1011. strcat (szObjDesc, itoa (nThreadCnt, szNum, 10));
  1013. /* locate base region */
  1014. VirtualQueryEx (lpDbgProcess->hProcess, (PVOID)nStack, &mbi, sizeof (mbi));
  1016. /* ignore invalid regions with a base region of 0 */
  1017. if (mbi.AllocationBase)
  1018.     {
  1019.     /* find all objects with same base region */
  1020.     for (i=0; i<nObjects; i++)
  1021. {
  1022. if (lpVMObject[i].mbi.AllocationBase == mbi.AllocationBase)
  1023.     {
  1024.     strcpy (lpVMObject[i].szObjType, "stack");
  1025.     strcpy (lpVMObject[i].szModule, szObjDesc);
  1026.     }
  1027. }
  1028.     }
  1030. /* locate and identify the guard page in each stack.
  1031.    The guard page is a single page of committed memory at the lower end of
  1032.    committed memory and immediately adjacent to the stack's reserved memory.
  1033.    If there is no more reserved stack space left, the guard page will be the
  1034.    last page of committed memory.  A stack cannot exist without a guard page.
  1035.    There will be at most three regions of memory in the stack: the actual stack
  1036.    space is committed, the guard page is committed and the remaining address
  1037.    space is marked reserved. */
  1038. /* locate lowest region of stack, since objects array is not sorted until after
  1039.    this function, it is always in ascending address order :) */
  1040. i=0;
  1041. while (i<nObjects &&
  1042.        (int)lpVMObject[i].mbi.BaseAddress < nStack &&
  1043.        lpVMObject[i].mbi.AllocationBase != mbi.AllocationBase)
  1044.     i++;
  1046. if (i<nObjects &&
  1047.     lpVMObject[i].mbi.AllocationBase == mbi.AllocationBase)
  1048.     {
  1049.     if (lpVMObject[i].mbi.State == MEM_RESERVE)
  1050. i++;
  1052.     /* identify guard page in section field */
  1053.     strcpy (lpVMObject[i].szSection, "guard");
  1054.     }
  1056. /* increment thread count */
  1057. nThreadCnt++;
  1059. /* increment list pointer */
  1060. pTh = (DBGTHREAD *)pTh->Next;
  1061. }
  1063.     /* name DLL objects in process */
  1064.     while (pDll != NULL)
  1065. {
  1066. /* locate dll base region */
  1067. VirtualQueryEx (lpDbgProcess->hProcess, pDll->lpBaseOfDll, &mbi, sizeof (mbi));
  1069. /* ignore invalid regions with a base region of 0 */
  1070. if (mbi.AllocationBase)
  1071.     {
  1072.     /* find all objects with same base region */
  1073.     for (i=0; i<nObjects; i++)
  1074. {
  1075. if (lpVMObject[i].mbi.AllocationBase == mbi.AllocationBase)
  1076.     {
  1077.     strcpy (lpVMObject[i].szObjType, "dll");
  1078.     strcpy (lpVMObject[i].szModule, pDll->szImageName);
  1079.     }
  1080. }
  1081.     }
  1083. /* name dll sections */
  1084. pSection = (SECTIONINFO *)pDll->lpSection;
  1085. while (pSection != NULL)
  1086.     {
  1087.     i = 0;
  1088.     while (i++<nObjects)
  1089. {
  1090. if (lpVMObject[i].mbi.BaseAddress ==
  1091. ((char *)pDll->lpBaseOfDll + pSection->uVirtualAddress))
  1092.     {
  1093.     strcpy (lpVMObject[i].szSection, pSection->szSection);
  1094.     break;
  1095.     }
  1096. }
  1097.     pSection = (SECTIONINFO *)pSection->Next;
  1098.     }
  1100. /* increment list pointer */
  1101. pDll = (DBGDLL *)pDll->Next;
  1102. }
  1104.     /* locate exe base region */
  1105.     VirtualQueryEx (lpDbgProcess->hProcess, lpDbgProcess->lpImage, &mbi, sizeof (mbi));
  1107.     /* ignore invalid regions with a base region of 0 */
  1108.     if (mbi.AllocationBase)
  1109. {
  1110. /* find all objects with same base region */
  1111. for (i=0; i<nObjects; i++)
  1112.     {
  1113.     if (lpVMObject[i].mbi.AllocationBase == mbi.AllocationBase)
  1114. {
  1115. strcpy (lpVMObject[i].szObjType, "exe");
  1116. strcpy (lpVMObject[i].szModule, lpDbgProcess->szModule);
  1117. }
  1118.     }
  1119. }
  1121.     /* name exe sections */
  1122.     pSection = lpDbgProcess->lpSection;
  1123.     while (pSection != NULL)
  1124. {
  1125. i = 0;
  1126. while (i++<nObjects)
  1127.     {
  1128.     if (lpVMObject[i].mbi.BaseAddress ==
  1129.     ((char *)lpDbgProcess->lpImage + pSection->uVirtualAddress))
  1130. {
  1131. strcpy (lpVMObject[i].szSection, pSection->szSection);
  1132. break;
  1133. }
  1134.     }
  1135. pSection = (SECTIONINFO *)pSection->Next;
  1136. }
  1137. }
  1142. /* find all occurrances of objects having same base region */
  1143. void WINAPI NameObjects (
  1144.     HANDLE   hProcess,
  1145.     LPVOID   lpAddress,
  1146.     LPVMOBJECT   lpVMObj,
  1147.     int    nObjects,
  1148.     char   *lpszObjType,
  1149.     char   *lpszModule)
  1150. {
  1151.     int  i;
  1152.     MEMORY_BASIC_INFORMATION mbi;
  1154.     /* locate base region */
  1155.     VirtualQueryEx (hProcess, lpAddress, &mbi, sizeof (mbi));
  1157.     /* ignore invalid regions with a base region of 0 */
  1158.     if (!mbi.AllocationBase)
  1159. return;
  1161.     /* find all objects with same base region */
  1162.     for (i=0; i<nObjects; i++)
  1163. {
  1164. if (lpVMObj[i].mbi.AllocationBase == mbi.AllocationBase)
  1165.     {
  1166.     strcpy (lpVMObj[i].szObjType, lpszObjType);
  1167.     strcpy (lpVMObj[i].szModule, lpszModule);
  1168.     }
  1169. }
  1170. }
  1175. void WINAPI IdentifyNewObjects (
  1176.     LPVMOBJECT   lpVMObjectOld,
  1177.     int    nObjectsOld,
  1178.     LPVMOBJECT   lpVMObject,
  1179.     int    nObjects)
  1180. {
  1181.     int    i, j;
  1183.     for (i=0; i<nObjects; i++)
  1184. {
  1185. for (j=0; j<nObjectsOld; j++)
  1186.     {
  1187.     if (VMCompare (lpVMObject+i, lpVMObjectOld+j))
  1188. goto NEXT;
  1189.     }
  1191. /* if not found must be a new item */
  1192. lpVMObject[i].bNew = TRUE;
  1193. NEXT:;
  1194. }
  1195. }
  1198. BOOL WINAPI VMCompare (
  1199.     LPVMOBJECT   lpVM1,
  1200.     LPVMOBJECT   lpVM2)
  1201. {
  1203.     /* compare memory info */
  1204.     if (lpVM1->mbi.AllocationBase      != lpVM2->mbi.AllocationBase   ||
  1205. lpVM1->mbi.BaseAddress        != lpVM2->mbi.BaseAddress   ||
  1206. lpVM1->mbi.RegionSize        != lpVM2->mbi.RegionSize    ||
  1207. lpVM1->mbi.Protect        != lpVM2->mbi.Protect   ||
  1208. lpVM1->mbi.AllocationProtect   != lpVM2->mbi.AllocationProtect   ||
  1209. lpVM1->mbi.State        != lpVM2->mbi.State   ||
  1210. lpVM1->mbi.Type         != lpVM2->mbi.Type      )
  1211. return FALSE;
  1213.     /* compare character information */
  1214.     if (memcmp ((LPVOID)lpVM1->szObjType, (LPVOID)lpVM2->szObjType, 12) ||
  1215. memcmp ((LPVOID)lpVM1->szSection,
  1216. (LPVOID)lpVM2->szSection,
  1217. IMAGE_SIZEOF_SHORT_NAME) ||
  1218. memcmp ((LPVOID)lpVM1->szModule, (LPVOID)lpVM2->szModule, MAX_PATH))
  1219. return FALSE;
  1221.     /* if still here, must be a match */
  1222.     return TRUE;
  1223. }
  1228. /* test to see if all memory objects in range are committed */
  1229. BOOL   WINAPI CommittedMemoryRange (
  1230.     int    i,
  1231.     int    j,
  1232.     LPVMOBJECT   lpvm,
  1233.     int    *Objects)
  1234. {
  1235.     int    k;
  1237.     /* test each memory object in range */
  1238.     for (k = min(i, j); k <= max (i, j); k++)
  1239. /* report any non committed memory regions */
  1240. if (lpvm[Objects[k]].mbi.State != MEM_COMMIT)
  1241.     return FALSE;
  1243.     /* report all committed range */
  1244.     return TRUE;
  1245. }
  1250. /* signal debugger thread to access process memory */
  1251. BOOL WINAPI AccessProcessMemory (
  1252.     HANDLE    hMemoryEvent,
  1253.     HANDLE    hAckEvent,
  1254.     LPVOID    lpAddress,
  1255.     LPVOID    lpBuffer,
  1256.     DWORD     *dwSize)
  1257. {
  1258.     DWORD    dwResult;
  1260.     /* copy data to module globals */
  1261.     PMAAddress = lpAddress;
  1262.     PMABuffer = lpBuffer;
  1263.     PMASize = *dwSize;
  1265.     /* signal debugger thread to read memory from process */
  1266.     SetEvent (hMemoryEvent);
  1268.     /* wait on debugger thread to signal completion of memory task */
  1269.     dwResult = WaitForSingleObject (hAckEvent, 100000);
  1270.     ResetEvent (hAckEvent);
  1272.     /* reset size accessed to verify operation */
  1273.     *dwSize = PMASize;
  1275.     return (dwResult == WAIT_OBJECT_0 &&
  1276.     PMASize != 0);
  1277. }
  1282. BOOL WINAPI InterruptThread_HookProcess (
  1283.     DBGPROCESS        *lpDbgProcess,
  1284.     LPPROCESS_STATE    lpState)
  1285. {
  1286.     DBGDLL *pDlls = lpDbgProcess->lpDlls;
  1287.     int  nBytes, nLen, i;
  1288.     MEMORY_BASIC_INFORMATION mbi;
  1289.     LPVOID lpLoadLibrary = NULL;
  1290.     char szKernel[] = "KERNEL32.DLL";
  1291.     char szFunction[] = "LoadLibraryA";
  1292.     BYTE pCode[PAGESIZE];
  1293.     BYTE pStack[PAGESIZE];
  1294.     HANDLE hDll;
  1297.     /* initialize stack and code pages */
  1298.     for (i=0; i<PAGESIZE; i++)
  1299. {
  1300. pStack[i] = 0;
  1301. pCode[i] = 0;
  1302. }
  1304.     /* find kernel32 Dll */
  1305.     while (pDlls != NULL)
  1306. {
  1307. if (!stricmp (pDlls->szImageName, szKernel))
  1308.     break;
  1309. pDlls = (DBGDLL *)pDlls->Next;
  1310. }
  1312.     /* if DLL not loaded abort */
  1313.     if (pDlls == NULL)
  1314. return FALSE;
  1316.     /* load the dll in this process, find the function offset in this
  1317.        process and normalize to the offset in the child process */
  1318.     hDll = LoadLibrary (szKernel);
  1319.     lpLoadLibrary = GetProcAddress (hDll, szFunction);
  1320.     VirtualQuery (lpLoadLibrary, &mbi, sizeof (mbi));
  1321.     (int)lpLoadLibrary += ((int)pDlls->lpBaseOfDll - (int)mbi.AllocationBase);
  1322.     FreeLibrary (hDll);
  1324.     /* get thread context information and save for replacement */
  1325.     lpState->Context.ContextFlags = CONTEXT_FULL;
  1326.     if (!GetThreadContext (lpDbgProcess->lpThreads->hThread, &(lpState->Context)))
  1327. return FALSE;
  1329. #ifdef _X86_
  1330.     lpState->Eip = (LPVOID)lpState->Context.Eip;
  1331.     lpState->Esp = (LPVOID)lpState->Context.Esp;
  1332. #elif defined(_PPC_)
  1333.     lpState->Eip = (LPVOID)lpState->Context.Iar;
  1334.     lpState->Esp = (LPVOID)lpState->Context.Gpr1;
  1335. #else /* MIPS */
  1336.     lpState->Eip = (LPVOID)lpState->Context.Fir;
  1337.     lpState->Esp = (LPVOID)lpState->Context.IntSp;
  1338. #endif
  1340.     /* locate first writeable code page in exe module */
  1341.     lpState->pCodePage = lpDbgProcess->lpImage;
  1342.     VirtualQueryEx (lpDbgProcess->hProcess, lpState->pCodePage, &mbi, sizeof (mbi));
  1343.     while (!(mbi.Protect & PAGE_READWRITE) &&
  1344.    mbi.AllocationBase == lpDbgProcess->lpImage)
  1345. {
  1346. (int)lpState->pCodePage = (int)mbi.BaseAddress + mbi.RegionSize;
  1347. VirtualQueryEx (lpDbgProcess->hProcess, lpState->pCodePage, &mbi, sizeof (mbi));
  1348. }
  1350.     if (mbi.AllocationBase != lpDbgProcess->lpImage)
  1351. return FALSE;
  1353.     /* save code page for reset process */
  1354.     ReadProcessMemory (lpDbgProcess->hProcess, lpState->pCodePage, lpState->Code, PAGESIZE, &nBytes);
  1356.     /* write DLL path to code page */
  1357.     strcpy ((char *)pCode, szCurPath);
  1358.     strcat ((char *)pCode, "\probe.dll");
  1359.     nLen = strlen ((char *)pCode) + 1;
  1361.     /* find current stack page and save  */
  1363. #ifdef _X86_
  1364.     lpState->pStackPage = (LPVOID)((((int)lpState->Context.Esp)/PAGESIZE) * PAGESIZE);
  1365. #elif defined(_PPC_)
  1366.     lpState->pStackPage = (LPVOID)((((int)lpState->Context.Gpr1)/PAGESIZE) * PAGESIZE);
  1367. #else /* MIPS */
  1368.     lpState->pStackPage = (LPVOID)((((int)lpState->Context.IntSp)/PAGESIZE) * PAGESIZE);
  1369. #endif
  1371.     ReadProcessMemory (lpDbgProcess->hProcess, lpState->pStackPage, lpState->Stack, PAGESIZE, &nBytes);
  1373.     /* push address of DLL string on stack */
  1374.     *((int *)(pStack+4092)) = (int)lpState->pCodePage;
  1376.     /* push return address on stack */
  1377.     *((int *)(pStack+4088)) = (int)lpState->pCodePage+nLen;
  1379.     /* return to Int 3 breakpoint instruction */
  1380.     pCode[nLen] = 0xCC;
  1382.     /* write new code and stack pages */
  1383.     WriteProcessMemory (lpDbgProcess->hProcess, lpState->pCodePage, pCode, PAGESIZE, &nBytes);
  1384.     WriteProcessMemory (lpDbgProcess->hProcess, lpState->pStackPage, pStack, PAGESIZE, &nBytes);
  1386.     /* update Eip to execute at actual LoadLibrary function */
  1387.     /* adjust stack pointer to point to return address */
  1389. #ifdef _X86_
  1390.     lpState->Context.Eip = (UINT)lpLoadLibrary;
  1391.     lpState->Context.Esp = (UINT)lpState->pStackPage+4088;
  1392. #elif defined(_PPC_)
  1393.     lpState->Context.Iar = (UINT)lpLoadLibrary;
  1394.     lpState->Context.Gpr1 = (UINT)lpState->pStackPage+4088;
  1395. #else /* _MIPS_ */
  1396.     lpState->Context.Fir = (UINT)lpLoadLibrary;
  1397.     lpState->Context.IntSp = (UINT)lpState->pStackPage+4088;
  1398. #endif
  1400.     if (!SetThreadContext (lpDbgProcess->lpThreads->hThread, &(lpState->Context)))
  1401. {
  1402. ReportError (IDS_ERRSETTHREADCONTEXT);
  1403. /* replace code and stack pages */
  1404. WriteProcessMemory (lpDbgProcess->hProcess, lpState->pCodePage, lpState->Code, PAGESIZE, &nBytes);
  1405. WriteProcessMemory (lpDbgProcess->hProcess, lpState->pStackPage, lpState->Stack, PAGESIZE, &nBytes);
  1406. return FALSE;
  1407. }
  1409.     return TRUE;
  1410. }
  1415. void WINAPI ResetInterruptedThread (
  1416.     DBGPROCESS        *lpDbgProcess,
  1417.     LPPROCESS_STATE    lpState)
  1418. {
  1419.     int    nBytes;
  1421.     /* return thread context information */
  1423. #ifdef _X86_
  1424.     lpState->Context.Eip = (UINT)lpState->Eip;
  1425.     lpState->Context.Esp = (UINT)lpState->Esp;
  1426. #elif defined(_PPC_)
  1427.     lpState->Context.Iar = (UINT)lpState->Eip;
  1428.     lpState->Context.Gpr1 = (UINT)lpState->Esp;
  1429. #else /* MIPS */
  1430.     lpState->Context.Fir = (UINT)lpState->Eip;
  1431.     lpState->Context.IntSp = (UINT)lpState->Esp;
  1432. #endif
  1434.     SetThreadContext (lpDbgProcess->lpThreads->hThread, &(lpState->Context));
  1436.     /* return code and stack information */
  1437.     WriteProcessMemory (lpDbgProcess->hProcess, lpState->pCodePage, lpState->Code, PAGESIZE, &nBytes);
  1438.     WriteProcessMemory (lpDbgProcess->hProcess, lpState->pStackPage, lpState->Stack, PAGESIZE, &nBytes);
  1439. }