home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / include / ImageModule.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-11  |  10.7 KB  |  405 lines
  1. //-----------------------------------------------------------------------------------//
  2. //              Windows Graphics Programming: Win32 GDI and DirectDraw               //
  3. //                             ISBN  0-13-086985-6                                   //
  4. //                                                                                   //
  5. //  Written            by  Yuan, Feng                             www.fengyuan.com   //
  6. //  Copyright (c) 2000 by  Hewlett-Packard Company                www.hp.com         //
  7. //  Published          by  Prentice Hall PTR, Prentice-Hall, Inc. www.phptr.com      //
  8. //                                                                                   //
  9. //  FileName   : imagemodule.cpp                                                     //
  10. //  Description: Using ImageHlp API for debug symbol querying                        //
  11. //  Version    : 1.00.000, May 31, 2000                                              //
  12. //-----------------------------------------------------------------------------------//
  13.  
  14. #define STRICT
  15. #define NOCRYPT
  16. #define WIN32_LEAN_AND_MEAN
  17.  
  18. // the newer imagehlp.h includes <wintrust.h>, the two macros fakes the include
  19. #define WINTRUST_H
  20. #define LPWIN_CERTIFICATE LPVOID
  21.  
  22. #include <windows.h>
  23. #include <imagehlp.h>
  24. #include <assert.h>
  25. #include <tchar.h>
  26. #include <stdio.h>
  27. #include <stdarg.h>
  28. #include <time.h>
  29.  
  30. #include "ImageModule.h"
  31.  
  32. KImageModule::KImageModule(HWND hOutput)
  33. {
  34.     m_hProcess          = GetCurrentProcess();
  35.     m_hOutput          = hOutput;
  36.  
  37.     m_bDecoratedNames = false;
  38.     m_bShowFPO          = false;
  39.     m_bForPogy          = false;
  40.     m_bLoaded          = false;
  41. }
  42.  
  43.  
  44. KImageModule::~KImageModule()
  45. {
  46.     Unload();
  47. }
  48.  
  49.  
  50. bool KImageModule::Load(char * filename, char *sympath)
  51. {
  52.     _tcscpy(m_modulename, filename);
  53.  
  54.     memset(& m_image, 0, sizeof(m_image));
  55.     
  56.     m_imagebase_loaded = (DWORD) GetModuleHandle(filename);
  57.  
  58.     if ( m_imagebase_loaded ) // module is already loaded, for example GDI32.DLL
  59.     {
  60.         m_imagebase_default = m_imagebase_loaded;
  61.         m_bLoaded            = false;
  62.  
  63.         PIMAGE_NT_HEADERS pNTHeader = ImageNtHeader((void *)m_imagebase_loaded);
  64.  
  65.         Output("%s already loaded at 0x%x %s\n", filename, m_imagebase_loaded,
  66.             ctime( (time_t *) & pNTHeader->FileHeader.TimeDateStamp));
  67.     }
  68.     else
  69.     {
  70.         if ( MapAndLoad(filename, NULL, & m_image, FALSE, TRUE) )
  71.             Output("%s loaded at 0x%x %s\n", m_image.ModuleName, m_image.MappedAddress, 
  72.                 ctime( (time_t *) & m_image.FileHeader->FileHeader.TimeDateStamp));
  73.         else
  74.         {
  75.             Output("Unable to load %s\n", filename);
  76.  
  77.             return false;
  78.         }
  79.  
  80.         m_imagebase_loaded  = (DWORD) m_image.MappedAddress;
  81.         m_imagebase_default = m_image.FileHeader->OptionalHeader.ImageBase;
  82.         m_bLoaded           = true;
  83.     }
  84.  
  85.     
  86.     if ( !SymInitialize(m_hProcess, sympath, FALSE) ) 
  87.     {
  88.         Output("SymInitialize failed\n\n");
  89.         return false;
  90.     }
  91.  
  92.     
  93.     m_symbolbase = SymLoadModule(m_hProcess, NULL, filename, 0, m_imagebase_loaded, 0 );
  94.     
  95.     if ( m_symbolbase==0 )
  96.     {
  97.         Output("SymLoadModule failed\n\n");
  98.         return false;
  99.     }
  100.  
  101.     IMAGEHLP_MODULE im;
  102.     im.SizeOfStruct = sizeof(im);
  103.  
  104.     SymGetModuleInfo( m_hProcess, m_symbolbase, &im );
  105.     
  106.     Output("""%s"" loaded. %s\n", im.LoadedImageName, ctime((time_t *) & im.TimeDateStamp));
  107.     
  108.     return true;
  109. }
  110.  
  111.  
  112. void KImageModule::Unload(void)
  113. {
  114.     SymUnloadModule(m_hProcess, m_symbolbase);
  115.     SymCleanup(m_hProcess);
  116.  
  117.     if ( m_image.ModuleName )
  118.         UnMapAndLoad(& m_image);
  119. } 
  120.  
  121.  
  122. const IMAGEHLP_SYMBOL * KImageModule::ImageGetSymbol(const char * name)
  123. {
  124.     char localname[MAX_PATH];
  125.  
  126.     memset(m_is, 0, sizeof(m_is));
  127.     m_is[0].SizeOfStruct  = sizeof(IMAGEHLP_SYMBOL);
  128.     m_is[0].MaxNameLength = sizeof(m_is) - sizeof(m_is[0]);
  129.     
  130.     // The silly implementation in imagehlp.dll will try to change the '!' in name
  131.     // to 0, which generates an access violation, because name would came from read-only
  132.     // constant data. Make a local copy to solve the problem
  133.     strcpy(localname, name);
  134.     
  135.     if ( SymGetSymFromName(m_hProcess, localname, m_is) )
  136.     {
  137.         // On Win2K RC1, m_is[0].Address is a valid address, m_pidi->ReservedMappedBase=NULL
  138.         if ( m_symbolbase )
  139.             m_is[0].Address += m_imagebase_default - m_symbolbase;
  140.         
  141.         return & m_is[0];
  142.     }
  143.     else
  144.     {
  145.         DWORD err = GetLastError();
  146.         return NULL;
  147.     }
  148. }
  149.  
  150.  
  151. bool KImageModule::LoadSystemModule(char * module, char* extension)
  152. {
  153.     char SymbolDir[MAX_PATH];
  154.  
  155.     GetSystemDirectory(SymbolDir, sizeof(SymbolDir)); // c:\winnt\system32
  156.  
  157.     char * p = strchr(SymbolDir, '\\');     // first '\\'
  158.     while ( p && strchr(p+1, '\\') )       // last '\\'    
  159.         p = strchr(p+1, '\\');
  160.  
  161.     if ( p )                                // c:\winnt
  162.         * p = NULL;
  163.  
  164.     strcat(SymbolDir, "\\symbols\\");
  165.     strcat(SymbolDir, extension);
  166.  
  167.     return Load(module, SymbolDir);
  168. }
  169.  
  170.  
  171. void KImageModule::ShowFPO(ULONG SymbolAddress)
  172. {
  173.     if ( m_bShowFPO )
  174.     {
  175.         const FPO_DATA * pFPO = (const FPO_DATA *) SymFunctionTableAccess(m_hProcess, SymbolAddress);
  176.         
  177.         if ( pFPO )
  178.         {
  179.             Output("         ");
  180.             Output("s=%4d l=%2d, p=%2d, e=%2d, r=%2d, s=%d, b=%d, f=%d\n",
  181.                     pFPO->cbProcSize,
  182.                     pFPO->cdwLocals,
  183.                     pFPO->cdwParams,
  184.                     pFPO->cbProlog,
  185.                     pFPO->cbRegs,
  186.                     pFPO->fHasSEH,
  187.                     pFPO->fUseBP,
  188.                     pFPO->cbFrame);
  189.         }
  190.     }
  191. }
  192.  
  193.  
  194. void KImageModule::TranslateName(LPSTR SymbolName)
  195. {
  196.     // If "decorated" names were specified, and if the name is "decorated," 
  197.     // undecorate it so that a human readable version can be displayed. 
  198.     
  199.     if ( m_bDecoratedNames /* && ('?' == *SymbolName) */ ) 
  200.     { 
  201.         char szUndecoratedName[0x400]; // Make symbol name buffers for the 
  202.         char szDecoratedName[0x400]; // decorated & undecorated versions 
  203.  
  204.         // Make a copy of the original SymbolName, so that we can modify it 
  205.  
  206.         lstrcpy( szDecoratedName, SymbolName ); 
  207.  
  208.         PSTR pEnd = szDecoratedName + lstrlen( szDecoratedName ); 
  209.  
  210.         // Strip everything off the end until we reach a 'Z' 
  211.  
  212.         //    while ( (pEnd > szDecoratedName) && (*pEnd != 'Z') ) 
  213.         //        *pEnd-- = 0; 
  214.  
  215.         // Call the IMAGEHLP function to undecorate the name 
  216.  
  217.         if ( 0 != UnDecorateSymbolName( szDecoratedName, szUndecoratedName, 
  218.             sizeof(szUndecoratedName), UNDNAME_COMPLETE | UNDNAME_32_BIT_DECODE ) ) 
  219.         { 
  220.             // End the output line with the undecorated name 
  221.             Output("         %s\n", szUndecoratedName ); 
  222.         } 
  223.     } 
  224. }
  225.  
  226.  
  227. // translate symbol va address symbva to RVA symbva - mappedBase
  228. // translate RVA to pointer within the loaded image
  229. const unsigned char * KImageModule::GetImagePointer(unsigned symbva)
  230. {
  231.     assert(m_imagebase_loaded);
  232.  
  233.     return (const unsigned char *) 
  234.         ImageRvaToVa(m_image.FileHeader, (void *) m_imagebase_loaded, 
  235.                         symbva - m_imagebase_default, NULL);
  236. }
  237.  
  238. // translate actual loaded pointer to to pointer within the loaded image
  239. const unsigned char * KImageModule::Address2ImagePointer(unsigned addr)
  240. {
  241.     assert(m_imagebase_loaded);
  242.  
  243.     return (const unsigned char *) 
  244.         ImageRvaToVa(m_image.FileHeader, (void *) m_imagebase_loaded, 
  245.                         addr - m_image.FileHeader->OptionalHeader.ImageBase, NULL);
  246. }
  247.  
  248.  
  249. BOOL KImageModule::EnumSymbolsCallback(LPSTR SymbolName, ULONG SymbolAddress, ULONG SymbolSize) 
  250. { 
  251.     unsigned callid = 0;
  252.     unsigned parano = 0;
  253.  
  254.     // translate symbol address SymbolAddress to RVA SymbolAddress - mappedBase
  255.     // translate RVA to pointer within the loaded image
  256.     const unsigned char * p;
  257.     
  258.     if ( m_bLoaded )
  259.         p = GetImagePointer(SymbolAddress);
  260.     else
  261.         p = (const unsigned char *) SymbolAddress;
  262.  
  263.     // Checking for system service call pattern
  264.     if ( ! IsBadReadPtr(p, 14) )
  265.     if ( (p[0]==0xB8) &&                                                  // mov eax, <callid>
  266.          (p[5]==0x8D) && (p[6]==0x54) && (p[7]==0x24) && (p[8]==0x04) &&  // lea edx, [esp+4]
  267.          (p[9]==0xCD) && (p[10]==0x2E) )                                  // int 2E
  268.     {
  269.         callid = * (unsigned *) (p+1);
  270.             
  271.         if ( p[11]==0xC2 )                                                  // ret <parasize>    
  272.             parano = * (unsigned short *) (p+12) / 4;
  273.     }
  274.     
  275.     if ( callid )
  276.     {
  277.         const IMAGEHLP_SYMBOL * pSymbol = ImageGetSymbol(SymbolName);
  278.  
  279.         // print out the RVA, and the symbol name passed to us. 
  280.         if ( m_bForPogy )
  281.         {                
  282.             Output( "D %s(", SymbolName);
  283.             for (unsigned i=0; i<parano; i++)
  284.             {
  285.                 Output("D");
  286.                 if ( i != (parano-1) )
  287.                     Output(",");
  288.             }
  289.             Output("), %08X, %x\n", pSymbol->Address, callid);
  290.         }
  291.         else
  292.         {
  293.             Output( "syscall(0x%04x, %2d) %08X %s!%s\n", callid, parano, pSymbol->Address, m_modulename, SymbolName); 
  294.     
  295.             ShowFPO(SymbolAddress);
  296.             TranslateName(SymbolName);
  297.         }
  298.         m_nCount ++;
  299.     }
  300.  
  301.     return TRUE; 
  302. } 
  303.  
  304.  
  305. BOOL CALLBACK EnumSymbolsCallback(LPSTR SymbolName, ULONG SymbolAddress, ULONG SymbolSize, 
  306.                                   PVOID UserContext ) 
  307. {
  308.     assert( ! IsBadReadPtr(UserContext, sizeof(KImageModule)) );
  309.  
  310.     return ((KImageModule *) UserContext)->EnumSymbolsCallback(SymbolName, SymbolAddress, SymbolSize);
  311. }
  312.  
  313.  
  314. void KImageModule::EnumerateSymbols(bool bForPogy)
  315. {
  316.     m_nCount  = 0;
  317.     m_bForPogy = bForPogy;
  318.  
  319.     SymEnumerateSymbols(m_hProcess, m_imagebase_loaded, ::EnumSymbolsCallback, this);
  320.  
  321.     Output("%d total syscalls found\n\n", m_nCount);
  322. }
  323.  
  324.  
  325. void KImageModule::ShowSysCallTable(const char * tablename, unsigned base)
  326. {
  327.     const IMAGEHLP_SYMBOL * pSymbol = ImageGetSymbol(tablename);
  328.  
  329.     if ( pSymbol==NULL )
  330.         Output("Unable to locate symbol %s\n", tablename);
  331.     else
  332.     {
  333.         int count = base;
  334.  
  335.         const unsigned * p = (const unsigned *) Address2ImagePointer(pSymbol->Address);
  336.  
  337.         while ( ! IsBadReadPtr(p, sizeof(unsigned)) )
  338.         {
  339.             unsigned q = * p;
  340.  
  341.             if ( q > (unsigned) (m_image.FileHeader->OptionalHeader.ImageBase) )
  342.             {
  343.                 DWORD           displacement;
  344.             //    IMAGEHLP_SYMBOL symbol;
  345.  
  346.                 memset(m_is, 0, sizeof(m_is));
  347.                 m_is[0].SizeOfStruct  = sizeof(IMAGEHLP_SYMBOL);
  348.                 m_is[0].MaxNameLength = sizeof(m_is) - sizeof(m_is[0]);
  349.     
  350.                 unsigned q1 = q;
  351.  
  352.                 // W2k RC1 imagehlp does not need translation
  353.                 if ( m_symbolbase )
  354.                     q1 = q1 - m_imagebase_default + m_symbolbase;
  355.  
  356.                 if ( SymGetSymFromAddr(m_hProcess, q1, & displacement, m_is) )
  357.                 {
  358.                     IMAGEHLP_LINE line;
  359.  
  360.                     line.SizeOfStruct = sizeof(line);
  361.  
  362.                     if ( SymGetLineFromAddr(m_hProcess, q1, & displacement, & line) )
  363.                     {
  364.                     }
  365.  
  366.                     Output("syscall(%4x) %s\n", count, m_is[0].Name);
  367.                     count ++;
  368.                 }
  369.             }
  370.             else
  371.                 break;
  372.             p++;
  373.         }
  374.  
  375.         Output("%d system calls found\n", count - base);
  376.     }
  377. }
  378.  
  379.  
  380. void KImageModule::va_Output(const char * format, va_list argptr)
  381. {
  382.     char buffer[1024];
  383.     
  384.     vsprintf(buffer, format, argptr);
  385.  
  386.     if ( m_hOutput )
  387.     {
  388.         SendMessage(m_hOutput, EM_SETSEL, 0xFFFFFF, 0xFFFFFF);
  389.         SendMessage(m_hOutput, EM_REPLACESEL, 0, (LPARAM) buffer);
  390.     }
  391.     else
  392.         OutputDebugString(buffer);
  393. }
  394.  
  395.  
  396. void KImageModule::Output(const char * format, ...)
  397. {
  398.     va_list ap;
  399.  
  400.     va_start(ap, format);
  401.     va_Output(format, ap);
  402.     va_end(ap);
  403. }
  404.  
  405.