Роббинс Д. - Отладка приложений для Microsoft .NET и Microsoft Windows - 2004

//Проверка наличия аргументов в командной строке. if ( 1 == argc )

{

ShowHelp ( ) ; return ;

}

//Необходим достаточно большой буфер для команды

//или параметров командной строки. TCHAR szCmdLine[ MAX_PATH + MAX_PATH ] ;

//Идентификатор процесса, если производится присоединение к нему. DWORD dwPID = 0 ;

szCmdLine[ 0 ] = _T ( '\0' ) ;

//Проверка, начинается ли командная строка со знака " ", так как это

//означает идентификатор процесса, к которому мы присоединяемся.

if ( _T ( ' ' ) == argv[1][0] )

{

//Попытка вычленить идентификатор процесса из командной строки.

//Передвинуться за символ ' ' в строке.

TCHAR * pPID = argv[1] + 1 ; dwPID = _tstol ( pPID ) ;

if ( 0 == dwPID )

{

_tprintf ( _T ( "Invalid PID value : %s\n" ) , pPID ) ; return ;

}

}

else

{

dwPID = 0 ;

// Я собираюсь запустить процесс. for ( int i = 1 ; i < argc ; i++ )

{

_tcscat ( szCmdLine , argv[ i ] ) ; if ( i < argc )

{

_tcscat ( szCmdLine , _T ( " " ) ) ;

}

}

}

//Место для возвращаемого значения. BOOL bRet = FALSE ;

//Установить обработчик CTRL+BREAK.

bRet = SetConsoleCtrlHandler ( CtrlBreakHandler , TRUE ) ;

см. след. стр.

162 ЧАСТЬ II Производительная отладка

if ( FALSE == bRet )

{

_tprintf ( _T ( "Unable to set CTRL+BREAK handler!\n" ) ) ; return ;

}

// Если идентификатор процесса равен 0, я запускаю процесс. if ( 0 == dwPID )

{

//Попытаемся запустить отлаживаемый процесс. Этот вызов функции

//выглядит, как обычный вызов CreateProcess, кроме специального

//необязательного флага DEBUG_ONLY_THIS_PROCESS.

memset ( &stProcessInfo , NULL , sizeof ( PROCESS_INFORMATION));

stStartInfo.cb = sizeof ( STARTUPINFO ) ;

//Не забудьте закрыть описатели процесса и потока,

//возвращаемые CreateProcess.

VERIFY ( CloseHandle ( stProcessInfo.hProcess ) ) ;

VERIFY ( CloseHandle ( stProcessInfo.hThread ) ) ;

//Посмотрим, запустился ли процесс отлаживаемой программы. if ( FALSE == bRet )

{

_tprintf ( _T ( "Unable to start %s\n" ) , szCmdLine ) ; return ;

}

//Сохранить идентификатор процесса на случай

//необходимости отсоединения.

dwPID = stProcessInfo.dwProcessId ;

}

else

{

bRet = DebugActiveProcess ( dwPID ) ; if ( FALSE == bRet )

{

_tprintf ( _T ( "Unable to attach to %u\n" ) , dwPID ) ; return ;

}

}

// Отлаживаемая программ запущена, поэтому запускаем цикл отладчика.

// Цикл до тех пор, пока не потребуется остановиться. while ( TRUE == bContinue )

{

// Пауза до возникновения события отладки.

BOOL bProcessDbgEvent = WaitForDebugEvent ( &stDE , 100 ) ;

if ( TRUE == bProcessDbgEvent )

{

//Обработка конкретных событий отладки.

//Так как MinDBG — это только минимальный отладчик,

//он обрабатывает только несколько событий.

DisplayCreateProcessEvent(stDE.u.CreateProcessInfo);

//Сохраним описатель, который понадобится позже.

//Заметьте: вы не можете закрыть этот описатель.

//Если вы это сделаете, CloseHandle завершится с ошибкой. hProcess = stDE.u.CreateProcessInfo.hProcess ;

//Описатель файла можно закрыть безболезненно.

//Если вы закроете поток, CloseHandle провалится

//глубоко в ContinueDebugEvent, когда вы будете

//завершать приложение. VERIFY(CloseHandle(stDE.u.CreateProcessInfo.hFile));

dwContinueStatus = DBG_CONTINUE ;

DisplayExitProcessEvent ( stDE.u.ExitProcess ) ; bContinue = FALSE ;

dwContinueStatus = DBG_CONTINUE ;

см. след. стр.

164 ЧАСТЬ II Производительная отладка

}

break ;

DisplayDllLoadEvent ( hProcess , stDE.u.LoadDll ) ;

// Не забудьте закрыть описатель соответствующего файла. VERIFY ( CloseHandle( stDE.u.LoadDll.hFile ) ) ;

dwContinueStatus = DBG_CONTINUE ;

}

break ;

case UNLOAD_DLL_DEBUG_EVENT :

{

DisplayDllUnLoadEvent ( stDE.u.UnloadDll ) ; dwContinueStatus = DBG_CONTINUE ;

}

break ;

//Заметьте, что вы не можете закрыть описатель потока.

//Если вы это сделаете, CloseHandle провалится глубоко

//в ContinueDebugEvent.

DisplayODSEvent ( hProcess , stDE.u.DebugString ) ; dwContinueStatus = DBG_CONTINUE ;

}

break ;

DisplayExceptionEvent ( stDE.u.Exception ) ;

//Единственное исключение, требующее специальной

//обработки, — это точка прерывания загрузчика. switch(stDE.u.Exception.ExceptionRecord.ExceptionCode)

{

case EXCEPTION_BREAKPOINT :

{

//Если возникает исключение по точке прерывания

//и оно первое, я продолжаю свое веселье, иначе

//я передаю исключение отлаживаемой программе.

if ( FALSE == bSeenInitialBP )

{

bSeenInitialBP = TRUE ; dwContinueStatus = DBG_CONTINUE ;

}

else

{

// Хьюстон, у нас проблема! dwContinueStatus =

DBG_EXCEPTION_NOT_HANDLED ;

}

}

break ;

//Все остальные исключения передаем

//отлаживаемой программе.

default :

{

dwContinueStatus =

DBG_EXCEPTION_NOT_HANDLED ;

}

break ;

}

}

break ;

// Для всех остальных событий – просто продолжаем. default :

{

dwContinueStatus = DBG_CONTINUE ;

}

break ;

}

// Передаем управление ОС. #ifdef _DEBUG

BOOL bCntDbg =

#endif

ContinueDebugEvent ( stDE.dwProcessId , stDE.dwThreadId , dwContinueStatus ) ;

см. след. стр.

166 ЧАСТЬ II Производительная отладка

ASSERT ( TRUE == bCntDbg ) ;

}

// Необходимо ли отсоединение? if ( TRUE == g_bDoTheDetach )

{

//Отсоединение работает только в XP или более поздней версии,

//поэтому я должен выполнить GetProcAddress, чтобы найти

//DebugActiveProcessStop.

bContinue = FALSE ;

HINSTANCE hKernel32 =

GetModuleHandle ( _T ( "KERNEL32.DLL" ) ) ; if ( 0 != hKernel32 )

{

PFNDEBUGACTIVEPROCESSSTOP pfnDAPS = (PFNDEBUGACTIVEPROCESSSTOP)

GetProcAddress ( hKernel32 ,

"DebugActiveProcessStop" ) ;

if ( NULL != pfnDAPS )

{

#ifdef _DEBUG

BOOL bTemp =

#endif

pfnDAPS ( dwPID ) ;

ASSERT ( TRUE == bTemp ) ;

}

}

}

}

}

/*////////////////////////////////////////////////////////////////////// // Мониторы обработки Ctrl+Break

//////////////////////////////////////////////////////////////////////*/

BOOL WINAPI CtrlBreakHandler ( DWORD dwCtrlType )

{

//Я буду обрабатывать только Ctrl+Break.

//Все другое убивает отлаживаемую программу. if ( CTRL_BREAK_EVENT == dwCtrlType )

{

g_bDoTheDetach = TRUE ; return ( TRUE ) ;

}

return ( FALSE ) ;

}

/*////////////////////////////////////////////////////////////////////// // Отображает справку к программе.

//////////////////////////////////////////////////////////////////////*/

/*////////////////////////////////////////////////////////////////////// // Отображение события создания процесса.

//////////////////////////////////////////////////////////////////////*/

void DisplayCreateProcessEvent ( CREATE_PROCESS_DEBUG_INFO & stCPDI )

{

}

/*////////////////////////////////////////////////////////////////////// // Отображение событий создания потока.

//////////////////////////////////////////////////////////////////////*/

void DisplayCreateThreadEvent ( DWORD dwTID , CREATE_THREAD_DEBUG_INFO & stCTDI )

{

см. след. стр.

168 ЧАСТЬ II Производительная отладка

}

/*////////////////////////////////////////////////////////////////////// // Отображение событий завершения потока.

//////////////////////////////////////////////////////////////////////*/

void DisplayExitThreadEvent ( DWORD dwTID , EXIT_THREAD_DEBUG_INFO & stETDI )

{

}

/*////////////////////////////////////////////////////////////////////// // Отображение событий завершения процесса.

//////////////////////////////////////////////////////////////////////*/

void DisplayExitProcessEvent ( EXIT_PROCESS_DEBUG_INFO & stEPDI )

{

}

/*//////////////////////////////////////////////////////////////////////

// Отображение событий загрузки DLL.

//////////////////////////////////////////////////////////////////////*/

static bool bSeenNTDLL = false ;

TCHAR szDLLName[ MAX_PATH ] ;

//NTDLL.DLL – это специальный случай. В W2K lpImageName равен NULL,

//а в XP он указывает просто на 'ntdll.dll', поэтому я сфабрикую

//загрузочную информацию.

if ( false == bSeenNTDLL )

{

bSeenNTDLL = true ;

UINT uiLen = GetWindowsDirectory ( szDLLName , MAX_PATH ) ;

ASSERT ( uiLen > 0 ) ;

if ( uiLen > 0 )

{

_tcscpy ( szDLLName + uiLen , _T ( "\\NTDLL.DLL" ) ) ;

}

else

{

_tcscpy ( szDLLName , _T ( "GetWindowsDirectory FAILED!" ));

}

}

else

{

szDLLName[ 0 ] = _T ( '\0' ) ;

//Значение в lpImageName является указателем на полный путь

//загружаемой DLL. Этот адрес находится в адресном пространстве

//отлаживаемой программы.

LPCVOID lpPtr = 0 ;

DWORD dwBytesRead = 0 ;

BOOL bRet = FALSE ;

//Если имя в отлаживаемой программе задано в UNICODE,

//я могу копировать его прямо в szDLLName,

//так как здесь все в UNICODE.

if ( TRUE == stLDDI.fUnicode )

{

//Иногда невозможно сразу считать весь буфер,

//содержащий имя, поэтому необходимо делать это

//частями, пока оно не будет считано целиком. DWORD dwSize = MAX_PATH * sizeof ( TCHAR ) ; do

{

см. след. стр.

170 ЧАСТЬ II Производительная отладка

dwSize = dwSize 20 ;

}

while ( ( FALSE == bRet ) && ( dwSize > 20 ) ) ;

}

else

{

// Считывание строки ANSI и преобразование ее в UNICODE. char szAnsiName[ MAX_PATH ] ;

DWORD dwAnsiSize = MAX_PATH ;

}

}

}

if ( _T ( '\0' ) == szDLLName[ 0 ] )

{

//С этой DLL связано несколько проблем. Попробуйте считать ее

//с помощью GetModuleHandleEx. Хотя вы и можете думать, что это

//будет работать, это только кажется, если не может быть получена

//информация о модуле этим способом. Если невозможно получить имя DLL

//вышеприведенной функцией, значит, вы в действительности имеете дело

//с перемещенной DLL.