Не работает пример LastMsgBoxInfo из книги Рихтера

[oljas_m]

Проект 2 - LastMsgBoxInfo(Exe)

LastMSgBoxInfo.cpp

#include "CmnHdr.h" /* See Appendix A. */
#include <windowsx.h>
#include <tchar.h>
#include "Resource.h"
#include "LastMsgBoxInfoLib.h"


BOOL Dlg_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam) {

chSETDLGICONS(hwnd, IDI_LASTMSGBOXINFO);
SetDlgItemText(hwnd, IDC_INFO,
TEXT("Waiting for a Message Box to be dismissed"));
return(TRUE);
}


void Dlg_OnSize(HWND hwnd, UINT state, int cx, int cy) {

SetWindowPos(GetDlgItem(hwnd, IDC_INFO), NULL,
0, 0, cx, cy, SWP_NOZORDER);
}


void Dlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) {

switch (id) {
case IDCANCEL:
EndDialog(hwnd, id);
break;
}
}


BOOL Dlg_OnCopyData(HWND hwnd, HWND hwndFrom, PCOPYDATASTRUCT pcds) {

// Some hooked process sent us some message box info, display it
SetDlgItemTextA(hwnd, IDC_INFO, (PCSTR) pcds->lpData);
return(TRUE);
}

INT_PTR WINAPI Dlg_Proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {

switch (uMsg) {
chHANDLE_DLGMSG(hwnd, WM_INITDIALOG, Dlg_OnInitDialog);
chHANDLE_DLGMSG(hwnd, WM_SIZE, Dlg_OnSize);
chHANDLE_DLGMSG(hwnd, WM_COMMAND, Dlg_OnCommand);
chHANDLE_DLGMSG(hwnd, WM_COPYDATA, Dlg_OnCopyData);
}
return(FALSE);
}

int WINAPI _tWinMain(HINSTANCE hinstExe, HINSTANCE, PTSTR pszCmdLine, int) {

DWORD dwThreadId = 0;
#ifdef _DEBUG
HWND hwnd = FindWindow(NULL, TEXT("Untitled - Paint"));
dwThreadId = GetWindowThreadProcessId(hwnd, NULL);
#endif

LastMsgBoxInfo_HookAllApps(TRUE, dwThreadId);
DialogBox(hinstExe, MAKEINTRESOURCE(IDD_LASTMSGBOXINFO) , NULL, Dlg_Proc);
LastMsgBoxInfo_HookAllApps(FALSE, 0);
return(0);
}

Resource.h

//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by LastMsgBoxInfo.rc
//

#define IDD_LASTMSGBOXINFO 101
#define IDI_LASTMSGBOXINFO 102
#define IDC_INFO 1001

// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 103
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1002
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

[oljas_m]

Ну и еще вот эти файлы есть...

toohelp.h

#pragma once


#include "CmnHdr.h" /* See Appendix A. */
#include <tlhelp32.h>
#include <tchar.h>

class CToolhelp {
private:
HANDLE m_hSnapshot;

public:
CToolhelp(DWORD dwFlags = 0, DWORD dwProcessID = 0);
~CToolhelp();

BOOL CreateSnapshot(DWORD dwFlags, DWORD dwProcessID = 0);

BOOL ProcessFirst(PPROCESSENTRY32 ppe) const;
BOOL ProcessNext(PPROCESSENTRY32 ppe) const;
BOOL ProcessFind(DWORD dwProcessId, PPROCESSENTRY32 ppe) const;

BOOL ModuleFirst(PMODULEENTRY32 pme) const;
BOOL ModuleNext(PMODULEENTRY32 pme) const;
BOOL ModuleFind(PVOID pvBaseAddr, PMODULEENTRY32 pme) const;
BOOL ModuleFind(PTSTR pszModName, PMODULEENTRY32 pme) const;

BOOL ThreadFirst(PTHREADENTRY32 pte) const;
BOOL ThreadNext(PTHREADENTRY32 pte) const;

BOOL HeapListFirst(PHEAPLIST32 phl) const;
BOOL HeapListNext(PHEAPLIST32 phl) const;
int HowManyHeaps() const;

// Note: The heap block functions do not reference a snapshot and
// just walk the process's heap from the beginning each time. Infinite
// loops can occur if the target process changes its heap while the
// functions below are enumerating the blocks in the heap.

BOOL HeapFirst(PHEAPENTRY32 phe, DWORD dwProcessID,
UINT_PTR dwHeapID) const;
BOOL HeapNext(PHEAPENTRY32 phe) const;
int HowManyBlocksInHeap(DWORD dwProcessID, DWORD dwHeapId) const;
BOOL IsAHeap(HANDLE hProcess, PVOID pvBlock, PDWORD pdwFlags) const;

public:
static BOOL EnableDebugPrivilege(BOOL fEnable = TRUE);
static BOOL ReadProcessMemory(DWORD dwProcessID, LPCVOID pvBaseAddress,
PVOID pvBuffer, DWORD cbRead, PDWORD pdwNumberOfBytesRead = NULL);
};


///////////////////////////////////////////////////////////////////////////////


inline CToolhelp::CToolhelp(DWORD dwFlags, DWORD dwProcessID) {

m_hSnapshot = INVALID_HANDLE_VALUE;
CreateSnapshot(dwFlags, dwProcessID);
}


///////////////////////////////////////////////////////////////////////////////


inline CToolhelp::~CToolhelp() {

if (m_hSnapshot != INVALID_HANDLE_VALUE)
CloseHandle(m_hSnapshot);
}


///////////////////////////////////////////////////////////////////////////////


inline int CToolhelp::CreateSnapshot(DWORD dwFlags, DWORD dwProcessID) {

if (m_hSnapshot != INVALID_HANDLE_VALUE)
CloseHandle(m_hSnapshot);

if (dwFlags == 0) {
m_hSnapshot = INVALID_HANDLE_VALUE;
} else {
m_hSnapshot = CreateToolhelp32Snapshot(dwFlags, dwProcessID);
}
return(m_hSnapshot != INVALID_HANDLE_VALUE);
}


///////////////////////////////////////////////////////////////////////////////


inline BOOL CToolhelp::EnableDebugPrivilege(BOO L fEnable) {

// Enabling the debug privilege allows the application to see
// information about service applications
BOOL fOk = FALSE; // Assume function fails
HANDLE hToken;

// Try to open this process's access token
if (OpenProcessToken(GetCurrentProcess (), TOKEN_ADJUST_PRIVILEGES,
&hToken)) {

// Attempt to modify the "Debug" privilege
TOKEN_PRIVILEGES tp;
tp.PrivilegeCount = 1;
LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &tp.Privileges[0].Luid);
tp.Privileges[0].Attributes = fEnable ? SE_PRIVILEGE_ENABLED : 0;
AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
fOk = (GetLastError() == ERROR_SUCCESS);
CloseHandle(hToken);
}
return(fOk);
}


///////////////////////////////////////////////////////////////////////////////


inline BOOL CToolhelp::ReadProcessMemory(DWORD dwProcessID,
LPCVOID pvBaseAddress, PVOID pvBuffer, DWORD cbRead,
PDWORD pdwNumberOfBytesRead) {

return(Toolhelp32ReadProcessMemory( dwProcessID, pvBaseAddress, pvBuffer,
cbRead, pdwNumberOfBytesRead));
}

Продолжение дальше....

[oljas_m]

///////////////////////////////////////////////////////////////////////////////


inline BOOL CToolhelp::ProcessFirst(PPROCESSENT RY32 ppe) const {

BOOL fOk = Process32First(m_hSnapshot, ppe);
if (fOk && (ppe->th32ProcessID == 0))
fOk = ProcessNext(ppe); // Remove the "[System Process]" (PID = 0)
return(fOk);
}


inline BOOL CToolhelp::ProcessNext(PPROCESSENTR Y32 ppe) const {

BOOL fOk = Process32Next(m_hSnapshot, ppe);
if (fOk && (ppe->th32ProcessID == 0))
fOk = ProcessNext(ppe); // Remove the "[System Process]" (PID = 0)
return(fOk);
}


inline BOOL CToolhelp::ProcessFind(DWORD dwProcessId, PPROCESSENTRY32 ppe)
const {

BOOL fFound = FALSE;
for (BOOL fOk = ProcessFirst(ppe); fOk; fOk = ProcessNext(ppe)) {
fFound = (ppe->th32ProcessID == dwProcessId);
if (fFound) break;
}
return(fFound);
}


///////////////////////////////////////////////////////////////////////////////


inline BOOL CToolhelp::ModuleFirst(PMODULEENTRY 32 pme) const {

return(Module32First(m_hSnapshot, pme));
}


inline BOOL CToolhelp::ModuleNext(PMODULEENTRY3 2 pme) const {

return(Module32Next(m_hSnapshot, pme));
}

inline BOOL CToolhelp::ModuleFind(PVOID pvBaseAddr, PMODULEENTRY32 pme) const {

BOOL fFound = FALSE;
for (BOOL fOk = ModuleFirst(pme); fOk; fOk = ModuleNext(pme)) {
fFound = (pme->modBaseAddr == pvBaseAddr);
if (fFound) break;
}
return(fFound);
}

inline BOOL CToolhelp::ModuleFind(PTSTR pszModName, PMODULEENTRY32 pme) const {
BOOL fFound = FALSE;
for (BOOL fOk = ModuleFirst(pme); fOk; fOk = ModuleNext(pme)) {
fFound = (lstrcmpi(pme->szModule, pszModName) == 0) ||
(lstrcmpi(pme->szExePath, pszModName) == 0);
if (fFound) break;
}
return(fFound);
}


///////////////////////////////////////////////////////////////////////////////


inline BOOL CToolhelp::ThreadFirst(PTHREADENTRY 32 pte) const {

return(Thread32First(m_hSnapshot, pte));
}


inline BOOL CToolhelp::ThreadNext(PTHREADENTRY3 2 pte) const {

return(Thread32Next(m_hSnapshot, pte));
}


///////////////////////////////////////////////////////////////////////////////


inline int CToolhelp::HowManyHeaps() const {

int nHowManyHeaps = 0;
HEAPLIST32 hl = { sizeof(hl) };
for (BOOL fOk = HeapListFirst(&hl); fOk; fOk = HeapListNext(&hl))
nHowManyHeaps++;
return(nHowManyHeaps);
}


inline int CToolhelp::HowManyBlocksInHeap(DWOR D dwProcessID,
DWORD dwHeapID) const {

int nHowManyBlocksInHeap = 0;
HEAPENTRY32 he = { sizeof(he) };
BOOL fOk = HeapFirst(&he, dwProcessID, dwHeapID);
for (; fOk; fOk = HeapNext(&he))
nHowManyBlocksInHeap++;
return(nHowManyBlocksInHeap);
}


inline BOOL CToolhelp::HeapListFirst(PHEAPLIST3 2 phl) const {

return(Heap32ListFirst(m_hSnapshot, phl));
}


inline BOOL CToolhelp::HeapListNext(PHEAPLIST32 phl) const {

return(Heap32ListNext(m_hSnapshot, phl));
}


inline BOOL CToolhelp::HeapFirst(PHEAPENTRY32 phe, DWORD dwProcessID,
UINT_PTR dwHeapID) const {

return(Heap32First(phe, dwProcessID, dwHeapID));
}


inline BOOL CToolhelp::HeapNext(PHEAPENTRY32 phe) const {

return(Heap32Next(phe));
}


inline BOOL CToolhelp::IsAHeap(HANDLE hProcess, PVOID pvBlock,
PDWORD pdwFlags) const {

HEAPLIST32 hl = { sizeof(hl) };
for (BOOL fOkHL = HeapListFirst(&hl); fOkHL; fOkHL = HeapListNext(&hl)) {
HEAPENTRY32 he = { sizeof(he) };
BOOL fOkHE = HeapFirst(&he, hl.th32ProcessID, hl.th32HeapID);
for (; fOkHE; fOkHE = HeapNext(&he)) {
MEMORY_BASIC_INFORMATION mbi;
VirtualQueryEx(hProcess, (PVOID) he.dwAddress, &mbi, sizeof(mbi));
if (chINRANGE(mbi.AllocationBase, pvBlock,
(PBYTE) mbi.AllocationBase + mbi.RegionSize)) {

*pdwFlags = hl.dwFlags;
return(TRUE);
}
}
}
return(FALSE);
}

[oljas_m]

cmnhdr.h

/*********************************** *********************************** ********
Модуль: CmnHdr.h
Замечания: Copyright (c) 2000 Jeffrey Richter
Назначение: Общий заголовочный файл содержащий полезные макросы и определения,
используемые во всех приложениях в книге. См. Приложение А.
*********************************** *********************************** ********/


#pragma once // Включить этот файл в сборку (build) только 1 раз


/////////////////////////////// Версия Windows ////////////////////////////////


#define _WIN32_WINNT 0x0500
//#define WINVER 0x0500


//////////////////////////////// Опция Unicode ////////////////////////////////


// Если мы не компилируем для x86 CPU, мы всегда компилируем с использованием
// unicode
#ifndef _M_IX86
#define UNICODE
#endif

// Чтобы компилировать с использованием Unicode на x86 CPU, раскомментируйте
// строку ниже
//#define UNICODE

// При использовании Windows Unicode функций также используем C-Runtime
// Unicode функции
#ifdef UNICODE
#define _UNICODE
#endif


///////////////// Включаем определения (definitions) Windows /////////////////


#pragma warning(push, 3)
#include <Windows.h>
#pragma warning(pop)
#pragma warning(push, 4)


///// Удостоверяемся что используются соотвествующие заголовочные файлы ///////


#ifndef WT_EXECUTEINPERSISTENTTHREAD
#pragma message("You are not using the latest Platform SDK header/library ")
#pragma message("files. This may prevent the project from building correctly.")
#endif


// Позволяем коду компилироваться без warning-сообщений на 4-м уровне предупреждений


/* nonstandard extension 'single line comment' was used */
#pragma warning(disable:4001)

// unreferenced formal parameter
#pragma warning(disable:4100)

// Note: Creating precompiled header
#pragma warning(disable:4699)

// function not inlined
#pragma warning(disable:4710)

// unreferenced inline function has been removed
#pragma warning(disable:4514)

// assignment operator could not be generated
#pragma warning(disable:4512)


//////////////////////// Вспомогательный макрос /////////////////////////


/*
Когда компилятор встречает такую строку:
#pragma chMSG(Fix this later)

Он выводит такую строку:

c:\CD\CmnHdr.h(82):Fix this later

Вы можете свободно прыгнуть на указанную строку в коде и изучить окружающий код
*/

#define chSTR2(x) #x
#define chSTR(x) chSTR2(x)
#define chMSG(desc) message(_ _FILE_ _ "(" chSTR(_ _LINE_ _) "):" #desc)


////////////////////////////// Макрос chINRANGE ////////////////////////////////


// Этот макрос возвращает TRUE если значение находится между двумя другими
#define chINRANGE(low, Num, High) (((low) <= (Num)) && ((Num) <= (High)))


//////////////////////////////// Макрос chDIMOF ////////////////////////////////


// Этот макрос определяет количество элементов в массиве.
#define chDIMOF(Array) (sizeof(Array) / sizeof(Array[0]))


///////////////////////////// Макрос chBEGINTHREADEX ///////////////////////////

Продолжение дальше...

[oljas_m]

// Этот макрос вызывает С runtime функцию _beginthreadex.
// C runtime библиотека не хочет иметь связь с типами данных Windows,
// такими как HANDLE. Это означает что Windows программист должен приводить
// типы значений при использовании _beginthreadex. Т.к. это очень неудобно,
// я создал этот макрос, выполняющий приведение типов.
typedef unsigned (__stdcall *PTHREAD_START) (void *);

#define chBEGINTHREADEX(psa, cbStack, pfnStartAddr, \
pvParam, fdwCreate, pdwThreadId) \
((HANDLE)_beginthreadex( \
(void *) (psa), \
(unsigned) (cbStack), \
(PTHREAD_START) (pfnStartAddr), \
(void *) (pvParam), \
(unsigned) (fdwCreate), \
(unsigned *) (pdwThreadId)))


/////// DebugBreak функция для x86 платформ///


#ifdef _X86_
#define DebugBreak() _asm { int 3 }
#endif


/////////////// Макрос возникновения исключительной ситуации


// Полезный макрос при создании ваших собственных исключительных ситуаций
#define MAKESOFTWAREEXCEPTION(Severity, Facility, Exception) \
((DWORD) ( \
/* Severity code */ (Severity ) | \
/* MS(0) or Cust(1) */ (1 << 29) | \
/* Reserved(0) */ (0 << 28) | \
/* Facility code */ (Facility << 16) | \
/* Exception code */ (Exception << 0)))


///////// Быстрый MessageBox макрос /////


inline void chMB(PCSTR s) {
char szTMP[128];
GetModuleFileNameA(NULL, szTMP, chDIMOF(szTMP));
MessageBoxA(GetActiveWindow(), s, szTMP, MB_OK);
}


/////////// Assert/Verify Макросы //////


inline void chFAIL(PSTR szMsg) {
chMB(szMsg);
DebugBreak();
}


// Выводит MessageBox с сообщением об ASSERT ошибке.
inline void chASSERTFAIL(LPCSTR file, int line, PCSTR expr) {
char sz[128];
wsprintfA(sz, "File %s, line %d : %s", file, line, expr);
chFAIL(sz);
}


// Выводит MessageBox если ASSERT обнаруживает ошибку при Debug сборке
#ifdef _DEBUG
#define chASSERT(x) if (!(x)) chASSERTFAIL(__FILE__, __LINE__, #x)
#else
#define chASSERT(x)
#endif


// Макрос chVERIFY в Debug-конфигурации заменяется на chASSERT,
// но в Release-конфигурации не удаляется из кода в отличие от ASSERT
#ifdef _DEBUG
#define chVERIFY(x) chASSERT(x)
#else
#define chVERIFY(x) (x)
#endif


/////////////////////////// Макрос chHANDLE_DLGMSG /////////////////////////////


// Стандартный макрос HANDLE_MSG из WindowsX.h работает некорректно с диалоговыми
// окнами, т.к. DlgProc возвращает BOOL вместо LRESULT (как WndProcs)
// Этот макрос исправляет данную проблему.
#define chHANDLE_DLGMSG(hwnd, message, fn) \
case (message): return (SetDlgMsgResult(hwnd, uMsg, \
HANDLE_##message((hwnd), (wParam), (lParam), (fn))))


////////////////// Макрос установки иконок в диалоговом окне ///////////////////


// Устанавливает иконки диалогового окна
inline void chSETDLGICONS(HWND hwnd, int idi) {
SendMessage(hwnd, WM_SETICON, TRUE, (LPARAM)
LoadIcon((HINSTANCE) GetWindowLongPtr(hwnd, GWLP_HINSTANCE),
MAKEINTRESOURCE(idi)));
SendMessage(hwnd, WM_SETICON, FALSE, (LPARAM)
LoadIcon((HINSTANCE) GetWindowLongPtr(hwnd, GWLP_HINSTANCE),
MAKEINTRESOURCE(idi)));
}


///////////////////////// Макрос проверки версии ОС ///////////////////////////


inline void chWindows9xNotAllowed() {
OSVERSIONINFO vi = { sizeof(vi) };
GetVersionEx(&vi);
if (vi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
chMB("This application requires features not present in Windows 9x.");
ExitProcess(0);
}
}


inline void chWindows2000Required() {
OSVERSIONINFO vi = { sizeof(vi) };
GetVersionEx(&vi);
if ((vi.dwPlatformId != VER_PLATFORM_WIN32_NT) && (vi.dwMajorVersion < 5)) {
chMB("This application requires features present in Windows 2000.");
ExitProcess(0);
}
}


///Макрос проверки UNICODE


// Т.к. Windows 98 не поддерживает Unicode, макрос выводит сообщение об ошибке
// и завершает процесс в случае, если Unicode приложение запускается
// в Windows 98

// Это достигается созданием глобального C++ объекта. Его конструктор выполняется
// перед вызовом Winmain.

#ifdef UNICODE

class CUnicodeSupported {
public:
CUnicodeSupported() {
if (GetWindowsDirectoryW(NULL, 0) <= 0) {
chMB("This application requires an OS that supports Unicode.");
ExitProcess(0);
}
}
};

// "static" позволяет избежать сообщения линкера о том,
// что существует несколько экземпляров объекта, когда проект
// содержит несколько исходных файлов
static CUnicodeSupported g_UnicodeSupported;

#endif

#pragma comment(linker, "/subsystem:Windows")