home *** CD-ROM | disk | FTP | other *** search
/ Windows Graphics Programming / Feng_Yuan_Win32_GDI_DirectX.iso / Samples / Chapt_03 / Fosterer / Fosterer.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-30  |  13.4 KB  |  571 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   : fosterer.cpp                                                         //
  10. //  Description: Hosting program for WinDBG debugger extension, Chapter 3            //
  11. //  Version    : 1.00.000, May 31, 2000                                              //
  12. //-----------------------------------------------------------------------------------//
  13.  
  14. #define STRICT
  15. #define WIN32_LEAN_AND_MEAN
  16.  
  17. #include <windows.h>
  18. #include <assert.h>
  19. #include <tchar.h>
  20. #include <imagehlp.h> 
  21. #include <richedit.h>
  22. #include <stdio.h>
  23. #include <commctrl.h>
  24. #include <wdbgexts.h>
  25.  
  26. #include "Extension.h"
  27. #include "Host.h"
  28. #include "ImageModule.h"
  29. #include "win.h"
  30. #include "resource.h"
  31. #include "memdump.h"
  32.  
  33. class KLogWindow : public KWindow
  34. {
  35.     virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  36.  
  37.     HINSTANCE m_hInst;
  38.     HWND      m_Output;
  39.  
  40.     void GetWndClassEx(WNDCLASSEX & wc)
  41.     {
  42.         KWindow::GetWndClassEx(wc);
  43.         wc.hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_SPY));
  44.     }
  45.  
  46. public:
  47.     KLogWindow(HINSTANCE hInst)
  48.     {
  49.         m_hInst   = hInst;
  50.     }
  51.  
  52.     void Dump(const char * cmd);
  53. };
  54.  
  55.  
  56. void KLogWindow::Dump(const char * cmd)
  57. {
  58.     if ( cmd==NULL )
  59.         return;
  60.  
  61.     //    ReadKRam(%08x, %d)
  62.     //  ReadURam(%x, %08x, %d)
  63.  
  64.     unsigned addr;
  65.     unsigned process;
  66.     int         length, len;
  67.     char   * buffer;
  68.     const char * p;
  69.  
  70.     if ( strncmp(cmd, "ReadKRam", 8)==0 )
  71.     {
  72.         p = strchr(cmd, '(') + 1; sscanf(p, "%x", & addr);
  73.         p = strchr(cmd, ',') + 1; sscanf(p, "%d", & length);
  74.  
  75.         assert( addr>=0x80000000 );
  76.         assert( length>0 );
  77.  
  78.         len = (length+15)/16*16;
  79.         buffer = new char[len];
  80.         assert( buffer );
  81.         memset(buffer, 0, len);
  82.         
  83.         theHost.pScope->Read(buffer, (const void *) addr, length);
  84.     }
  85.     else if ( strncmp(cmd, "ReadURam", 8)==0 )
  86.     {
  87.         p = strchr(cmd, '(') + 1; sscanf(p, "%x", & process);
  88.         p = strchr(p,   ',') + 1; sscanf(p, "%x", & addr);
  89.         p = strchr(p,   ',') + 1; sscanf(p, "%d", & length);
  90.  
  91.         len = (length+15)/16*16;
  92.  
  93.         buffer = new char[len];
  94.         assert(buffer);
  95.         memset(buffer, 0, len);
  96.         DWORD dwRead;
  97.         ReadProcessMemory((HANDLE) process, (const void *) addr, buffer, length, & dwRead);
  98.     }
  99.  
  100.     if ( buffer )
  101.     {
  102.         KMemDump dump;
  103.  
  104.         dump.OpenDump();
  105.         dump.Dump((unsigned char *)buffer, addr - (unsigned) buffer, length, 4);
  106.         dump.CloseDump();
  107.  
  108. //        if ( length==1548 )
  109. //        {
  110. //            TestDCObj(buffer);
  111. //        }
  112.         
  113.         delete [] buffer;
  114.     }
  115. }
  116.  
  117.  
  118. LRESULT KLogWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  119. {
  120.     switch( uMsg )
  121.     {
  122.         case WM_CREATE:
  123.         {
  124.             RECT rect;
  125.  
  126.             m_hWnd  = hWnd;
  127.             
  128.             GetClientRect(m_hWnd, & rect);
  129.  
  130.             m_Output = CreateWindowEx(WS_EX_CLIENTEDGE, RICHEDIT_CLASS, NULL, 
  131.                 WS_CHILD | WS_VISIBLE | WS_BORDER | WS_HSCROLL | WS_VSCROLL |
  132.                 ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOVSCROLL | ES_WANTRETURN,
  133.                 0, 0, rect.right, rect.bottom,
  134.                 m_hWnd, (HMENU) 101, m_hInst, NULL);
  135.  
  136.             SendMessage(m_Output, EM_LIMITTEXT, 1024 * 1024, 0);
  137.             SendMessage(m_Output, WM_SETFONT, (WPARAM) GetStockObject(ANSI_FIXED_FONT), FALSE);;
  138.  
  139.             theHost.hwndLog = m_Output;
  140.         }
  141.         return 0;
  142.  
  143.         case WM_PARENTNOTIFY:
  144.             if ( LOWORD(wParam)==WM_RBUTTONDOWN )
  145.             {
  146.                 char buffer[MAX_PATH];
  147.  
  148.                 buffer[0] =0 ;
  149.                 SendMessage(m_Output, EM_GETSELTEXT, 0, (LPARAM) & buffer);
  150.                 Dump(buffer);
  151.             }
  152.             return 0;
  153.         
  154.         case WM_SIZE:
  155.         {
  156.             int width       = LOWORD(lParam);
  157.             int height       = HIWORD(lParam);
  158.     
  159.             MoveWindow(m_Output, 0, 0, width, height, TRUE);
  160.         }
  161.         return 0;
  162.     }
  163.  
  164.     return DefWindowProc(hWnd, uMsg, wParam, lParam);
  165. };
  166.  
  167.  
  168. class KMainWindow : public KWindow
  169. {
  170.     virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  171.  
  172.     HWND      m_Output;
  173.     HWND      m_Command;
  174.     HWND      m_Action;
  175.     HWND      m_Pid;
  176.  
  177.     DWORD      m_curPid;
  178.     HANDLE      m_curProcess;
  179.  
  180.     HINSTANCE m_hInst;
  181.  
  182.     void GetWndClassEx(WNDCLASSEX & wc)
  183.     {
  184.         KWindow::GetWndClassEx(wc);
  185.         wc.hbrBackground = GetSysColorBrush(COLOR_MENU);
  186.         wc.hIcon         = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_SPY));
  187.     }
  188.  
  189. public:
  190.  
  191.     KGDIExtension gdi;
  192.     
  193.     KMainWindow(HINSTANCE hInst)
  194.     {
  195.         m_hInst   = hInst;
  196.         
  197.         m_Output  = NULL;
  198.         m_Command = NULL;
  199.         m_Action  = NULL;
  200.         m_Pid     = NULL;
  201.     }
  202.  
  203.     HANDLE GetProcess(void);
  204. };
  205.  
  206.  
  207. HANDLE KMainWindow::GetProcess(void)
  208. {
  209.     char sPid[64];
  210.     DWORD nPid;
  211.  
  212.     GetWindowText(m_Pid, sPid, sizeof(sPid));
  213.     sscanf(sPid, "%x", & nPid);
  214.  
  215.     if ( nPid != m_curPid )
  216.     {
  217.         HANDLE hProcess = OpenProcess(PROCESS_VM_READ, FALSE, nPid);
  218.  
  219.         if ( hProcess == NULL )
  220.         {
  221.             wsprintf(sPid, "Unable to open process %x", nPid);
  222.             MyMessageBox(NULL, sPid, "Fosterer", MB_OK, IDI_SPY);
  223.         }
  224.         else
  225.         {
  226.             CloseHandle(m_curProcess);
  227.  
  228.             m_curPid = nPid;
  229.             m_curProcess = hProcess;
  230.         }
  231.     }
  232.  
  233.     return m_curProcess;
  234. }
  235.  
  236.  
  237. LRESULT KMainWindow::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  238. {
  239.     switch( uMsg )
  240.     {
  241.         case WM_CREATE:
  242.             {
  243.                 RECT rect;
  244.  
  245.                 m_hWnd  = hWnd;
  246.             
  247.                 GetClientRect(m_hWnd, & rect);
  248.  
  249.                 int textheight = GetSystemMetrics(SM_CYSIZE) * 13 / 10;
  250.  
  251.                 m_curPid     = GetCurrentProcessId();
  252.                 m_curProcess = GetCurrentProcess();
  253.  
  254.                 char id[32];
  255.                 wsprintf(id, "%x", m_curPid);
  256.                 
  257.                 m_Pid  = CreateWindowEx(0, "EDIT", id,
  258.                     WS_CHILD | WS_VISIBLE | WS_BORDER,
  259.                     8, 0, 80, textheight,
  260.                     m_hWnd, NULL, m_hInst, NULL);
  261.  
  262.                 m_Action  = CreateWindowEx(0, "BUTTON", "Do",
  263.                     WS_CHILD | WS_VISIBLE | WS_BORDER,
  264.                     100, 0, 80, textheight,
  265.                     m_hWnd, (HMENU) IDOK, m_hInst, NULL);
  266.  
  267.                 m_Command = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", NULL, 
  268.                     WS_CHILD | WS_VISIBLE | WS_BORDER, 
  269.                     200, 0, rect.right - 200, textheight, 
  270.                     m_hWnd, NULL, m_hInst, NULL);
  271.                 assert(m_Command);
  272.  
  273.                 m_Output = CreateWindowEx(WS_EX_CLIENTEDGE, RICHEDIT_CLASS, NULL, 
  274.                     WS_CHILD | WS_VISIBLE | WS_BORDER | WS_HSCROLL | WS_VSCROLL |
  275.                     ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOVSCROLL | ES_WANTRETURN,
  276.                     0, textheight + 1, rect.right, rect.bottom - textheight - 1,
  277.                     m_hWnd, NULL, m_hInst, NULL);
  278.  
  279.                 assert(m_Output);
  280.                 SendMessage(m_Output, WM_SETFONT, (WPARAM) GetStockObject(ANSI_FIXED_FONT), FALSE);;
  281.  
  282.                 theHost.hwndOutput = m_Output; 
  283.             }
  284.             return 0;
  285.  
  286.         case WM_SIZE:
  287.             {
  288.                 int width       = LOWORD(lParam);
  289.                 int height       = HIWORD(lParam);
  290.                 int textheight = GetSystemMetrics(SM_CYSIZE) * 13 / 10;
  291.  
  292.                 MoveWindow(m_Pid,      10, 0,            80,          textheight, FALSE);
  293.                 MoveWindow(m_Action,  100, 0,            80,          textheight, FALSE);
  294.                 MoveWindow(m_Command, 200, 0,            width - 200, textheight, TRUE);
  295.                 MoveWindow(m_Output,  0,   textheight+1, width,       height - textheight-1, TRUE);
  296.             }
  297.             return 0;
  298.  
  299.         case WM_PAINT:
  300.             {
  301.                 PAINTSTRUCT ps; 
  302.                 
  303.                 BeginPaint(m_hWnd, &ps);
  304.                 EndPaint(m_hWnd, &ps);
  305.             }
  306.             return 0;
  307.  
  308.         case WM_COMMAND:
  309.                 
  310.  
  311.             switch ( LOWORD(wParam) )
  312.             {
  313.                 case IDOK:
  314.                     {
  315.                         char text[MAX_PATH];
  316.  
  317.                         GetWindowText(m_Command, text, sizeof(text));
  318.  
  319.                         gdi.SetProcess(GetProcess());
  320.                         gdi.Do(text);
  321.                     }
  322.                     return 0;
  323.  
  324.                 case ID_EXIT:
  325.                     DestroyWindow(hWnd);
  326.                     return 0;
  327.  
  328.                 case ID_HELP_GDIKDX:
  329.                     gdi.Do("help");
  330.                     return 0;
  331.  
  332.                 case ID_HELP_DUMPHMGR:
  333.                     gdi.Do("dumphmgr -?");
  334.                     return 0;
  335.  
  336.                 case ID_HELP_DUMPOBJ:
  337.                     gdi.Do("dumpobj -?");
  338.                     return 0;
  339.  
  340.                 case ID_CMD_DUMPHMGR:
  341.                     gdi.Do("dumphmgr");
  342.                     return 0;
  343.  
  344.                 case ID_CMD_DUMPOBJ:
  345.                     gdi.Do("dumpobj");
  346.                     return 0;
  347.  
  348.                 case ID_CMD_DPDEV:
  349.                     gdi.Do("dpdev");
  350.                     return 0;
  351.  
  352.                 case ID_CMD_DLDEV:
  353.                     gdi.Do("dldev");
  354.                     return 0;
  355.  
  356.                 case ID_CMD_DGDEV:
  357.                     gdi.Do("dgdev");
  358.                     return 0;
  359.             }
  360.             break;
  361.  
  362.         case WM_DESTROY:
  363.             PostQuitMessage(0);
  364.             return 0;
  365.     }
  366.  
  367.     return DefWindowProc(hWnd, uMsg, wParam, lParam);
  368. }
  369.  
  370.  
  371. // 8x8 24-bit DIB
  372. typedef struct
  373. {
  374.     BITMAPINFOHEADER bmiHeader; 
  375.     unsigned char    bmiBits[8*3*8];
  376. }  CSmallDib;
  377.  
  378.  
  379. // 8x8 24 bit DIB
  380. const CSmallDib dib = 
  381. { 
  382.     { sizeof(BITMAPINFOHEADER), 8, 8, 1, 24,  BI_RGB, 8*3*8, 0, 0, 0, 0 }, 
  383.  
  384.     {   0,0,0, 1,1,1, 2,2,2, 3,3,3, 4,4,4, 5,5,5, 6,6,6, 7,7,7,
  385.         1,1,1, 2,2,2, 3,3,3, 4,4,4, 5,5,5, 6,6,6, 7,7,7, 0,0,0, 
  386.         2,2,2, 3,3,3, 4,4,4, 5,5,5, 6,6,6, 7,7,7, 0,0,0, 1,1,1, 
  387.         3,3,3, 4,4,4, 5,5,5, 6,6,6, 7,7,7, 0,0,0, 1,1,1, 2,2,2, 
  388.         4,4,4, 5,5,5, 6,6,6, 7,7,7, 0,0,0, 1,1,1, 2,2,2, 3,3,3, 
  389.         5,5,5, 6,6,6, 7,7,7, 0,0,0, 1,1,1, 2,2,2, 3,3,3, 4,4,4, 
  390.         6,6,6, 7,7,7, 0,0,0, 1,1,1, 2,2,2, 3,3,3, 4,4,4, 5,5,5, 
  391.         7,7,7, 0,0,0, 1,1,1, 2,2,2, 3,3,3, 4,4,4, 5,5,5, 6,6,6 
  392.     }
  393. };
  394.  
  395.  
  396. long FIXARRAY[] =
  397. {
  398.           0x00000630, 0xfffffff8, 
  399.           0x00000630, 0xfffffc89, 
  400.           0x00000368, 0xfffff9c0, 
  401.           0xfffffff8, 0xfffff9c0, 
  402.           0xfffffc88, 0xfffff9c0, 
  403.           0xfffff9c0, 0xfffffc89, 
  404.           0xfffff9c0, 0xfffffff8, 
  405.           0xfffff9c0, 0x00000367, 
  406.           0xfffffc88, 0x00000630, 
  407.           0xfffffff8, 0x00000630, 
  408.           0x00000368, 0x00000630, 
  409.           0x00000630, 0x00000367, 
  410.           0x00000630, 0xfffffff8 
  411. };
  412.  
  413.  
  414. const POINT Points[3] = { {200, 50}, {250, 150}, {300, 50} };
  415.  
  416.  
  417. void GDITest(void)
  418. {
  419.     ENUMLOGFONTEXW enumlog;
  420.     EXTLOGFONTW extlog;
  421.     
  422.     memset(& enumlog, 0, sizeof(enumlog));
  423.     memset(& extlog, 0, sizeof(extlog));
  424.  
  425.     int j = sizeof(enumlog);
  426.     int k = sizeof(extlog);
  427.     
  428.     for (int i=0; i<sizeof(FIXARRAY)/sizeof(long); i++)
  429.     {
  430.         char t[20];
  431.  
  432.         long v = FIXARRAY[i];
  433.  
  434.         if ( v >= 0)
  435.             t[0] = '+';
  436.         else
  437.         {
  438.             t[0] = '-';
  439.             v = - v;
  440.         }
  441.  
  442.         sprintf(t+1, "%d + %d/16\n", v/16, v%16);
  443.         OutputDebugString(t);
  444.     }
  445.  
  446.     HDC hDC = GetDC(NULL);
  447.     
  448.     HBITMAP bmp1 = CreateBitmap(100, 100, 1, 1, NULL);
  449.     HBITMAP bmp2 = CreateBitmap(100, 100, 1, 4, NULL);
  450.     HBITMAP bmp3 = CreateBitmap(100, 100, 1, 8, NULL);
  451.     HBITMAP bmp4 = CreateBitmap(100, 100, 3, 8, NULL);
  452.     HBITMAP bmp5 = CreateBitmap(100, 100, 1, 24, NULL);
  453.  
  454.     void * dibbits;
  455.  
  456.     HBITMAP bmp6 = CreateDIBSection(hDC, (BITMAPINFO *) & dib, 
  457.                         DIB_RGB_COLORS, & dibbits, NULL, 0);
  458.  
  459.     BeginPath(hDC);
  460.     MoveToEx(hDC, 100, 100, NULL);
  461.     LineTo(hDC, 150, 150);
  462.     PolyBezierTo(hDC, & Points[0], 3);
  463.     CloseFigure(hDC);
  464.     Ellipse(hDC, -100, -100, 100, 100);
  465.     EndPath(hDC);
  466.     POINT points[20];
  467.     BYTE  types[20];
  468.  
  469.     int n = GetPath(hDC, NULL, NULL, 0);
  470.     n = GetPath(hDC, points, types, min(n, 20));
  471.  
  472.     SetBitmapDimensionEx(bmp1, 10000, 10000, NULL);
  473. }
  474.  
  475. void GetFullName(HINSTANCE hInstance, const TCHAR * module, TCHAR fullname[])
  476. {
  477.     GetModuleFileName(hInstance, fullname, MAX_PATH);
  478.  
  479.     TCHAR * pName = fullname;
  480.  
  481.     while ( _tcschr(pName, ':') || _tcschr(pName, '\\') )
  482.         if ( _tcschr(pName, ':') )
  483.             pName = _tcschr(pName, ':') + 1;
  484.         else
  485.             pName = _tcschr(pName, '\\') + 1;
  486.  
  487.     if ( pName )
  488.         _tcscpy(pName, module);
  489. }
  490.  
  491.  
  492. int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR lpCmd, int nShow)
  493. {
  494.     if ( LoadLibrary("RICHED20.DLL")==NULL )
  495.     {
  496.         MyMessageBox(NULL, "Unable to load RICHED20.DLL", "Fosterer", MB_OK, IDI_SPY);
  497.         return -1;
  498.     }
  499.     
  500.     KMainWindow win(hInst);
  501.     KLogWindow  log(hInst);
  502.     
  503.     log.CreateEx(0, "LogWindow", "LogWindow",
  504.                  WS_OVERLAPPEDWINDOW,
  505.                  CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
  506.                  NULL, NULL, hInst);
  507.     log.ShowWindow(nShow);
  508.     log.UpdateWindow();
  509.  
  510.     win.CreateEx(0, "Fosterer", "Fosterer",
  511.                  WS_OVERLAPPEDWINDOW,
  512.                  CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
  513.                  NULL, LoadMenu(hInst, MAKEINTRESOURCE(IDR_MAIN)), hInst);
  514.         
  515.     win.ShowWindow(nShow);
  516.     win.UpdateWindow();
  517.  
  518.     KPeriscopeClient scope("PeriScope");
  519.     KImageModule     win32k;
  520.  
  521.     TCHAR fullname[MAX_PATH];
  522.     GetFullName(hInst, "periscope.sys", fullname);
  523.  
  524.     if ( scope.Load(fullname)==ERROR_SUCCESS )
  525.     {
  526.         theHost.ExtOutput("Periscope loaded\n");
  527.  
  528.         try
  529.         {
  530.             char SysDir[MAX_PATH];
  531.  
  532.             GetSystemDirectory(SysDir, sizeof(SysDir)); // c:\winnt\system32
  533.  
  534.             char * p = strchr(SysDir, '\\');   // first '\\'
  535.             while ( p && strchr(p+1, '\\') )   // last '\\'    
  536.                 p = strchr(p+1, '\\');
  537.  
  538.             if ( p )                           // c:\winnt
  539.                 * p = NULL;
  540.  
  541.             strcat(SysDir, "\\symbols\\sys");
  542.  
  543.             if ( win32k.Load("win32k.sys", SysDir) )
  544.             {
  545.                 theHost.pWin32k = & win32k;
  546.                 theHost.pScope  = & scope;
  547.     
  548.                 if ( ! win.gdi.Load(& ExtensionAPI, "gdikdx.dll") )
  549.                     MyMessageBox(NULL, "Unable to load GDI kernel extension GDIKDX.DLL.\n", "Fosterer", MB_OK, IDI_SPY);
  550.             }
  551.             else
  552.                 MyMessageBox(NULL, "Unable to load win32k.sys debug information", "Fosterer", MB_OK, IDI_SPY);
  553.         }
  554.         catch (...)
  555.         {
  556.             OutputDebugString("Exception in WinMain");
  557.         }
  558.     }
  559.     else
  560.         MyMessageBox(NULL, fullname, "Unable to load kernel mode driver", MB_OK, IDI_SPY);
  561.  
  562.     win.MessageLoop();
  563.  
  564.     DestroyWindow(log.m_hWnd);
  565.  
  566.     scope.Close();
  567.  
  568.     return 0;
  569. }
  570.  
  571.