home *** CD-ROM | disk | FTP | other *** search
/ Media Share 13 / mediashare_13.zip / mediashare_13 / ZIPPED / PROGRAM / DDJ9403A.ZIP / UC394.ZIP / GATEVIEW.C < prev    next >
C/C++ Source or Header  |  1993-12-19  |  32KB  |  938 lines
  1. /************************************************************
  2.   GATEVIEW.C -- system info viewer, uses installable VxD RINGO
  3.   by Alex Shmidt, November 1993
  4. ************************************************************/
  5.  
  6. #define WINVER   0x30a    /* for Win 3.1 SDK to get compatible with 3.0 */
  7. #include <windows.h>
  8. #include "386.h"
  9. #include "ringo.h"
  10. #include "gateview.h"
  11. #include "gatehlp.h"
  12.  
  13. #define WM_RINGO 0      /* RINGO's message WM_USER + WM_RINGO */
  14.  
  15. long  FAR PASCAL WndProc (HWND,WORD,WORD,LONG);
  16. void  PrintDescriptor (LPSTR, LPSEGDESCRIPTOR, int, BYTE);
  17. BOOL  ParsePageEntry (LPPAGE, LPPGMAP);
  18. BYTE  ParseDescriptor (LPSEGDESCRIPTOR, LPSEGDESCMAP);
  19. LPSTR PrintPageType (LPPGMAP, LPSTR);
  20. BOOL  PageDir (LPSTR, LPPAGE, int);
  21. DWORD PageTable (LPSTR, LPPAGE, int, int);
  22. void  PageDirListBox (HWND, LPSTR, UINT);
  23. void  GDTListBox (HWND, LPSTR, UINT);
  24. void  LDTListBox (HWND, LPSTR, UINT);
  25. void  IDTListBox (HWND, LPSTR, UINT);
  26. void  TSSListBox (HWND, LPSTR);
  27. void  CRDRListBox (HWND, LPSTR);
  28. void  VxDListBox (HWND, LPSTR);
  29. void  VMListBox  (HWND, LPSTR);
  30. void  LoadControlInfo (WORD,LPMSGSTRUC,LPSTR);
  31. DWORD GetPageTableVM (DWORD);
  32. void  PhysListBox (HWND, LPSTR, DWORD);
  33.  
  34. SYSTEMSTRUCT   sysstruct;
  35. UINT     uSelector1, uSelector2;
  36.  
  37. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpszCmdParam,
  38.                         int nCmdShow)
  39. {
  40. static char szAppName[] = "GateView";
  41. HWND        hwnd;
  42. MSG         msg;
  43. WNDCLASS    wndclass;
  44.  
  45.   if (!hPrevInstance)
  46.   {
  47.     wndclass.style          = CS_HREDRAW | CS_VREDRAW;
  48.     wndclass.lpfnWndProc    = (WNDPROC) WndProc;
  49.     wndclass.cbClsExtra     = 0;
  50.     wndclass.cbWndExtra     = DLGWINDOWEXTRA;
  51.     wndclass.hInstance      = hInstance;
  52.     wndclass.hIcon          = LoadIcon (NULL, IDI_APPLICATION);
  53.     wndclass.hCursor        = LoadCursor (NULL,IDC_ARROW);
  54.     wndclass.hbrBackground  = COLOR_WINDOW + 1;
  55.     wndclass.lpszMenuName   = NULL;
  56.     wndclass.lpszClassName  = szAppName;
  57.  
  58.     RegisterClass (&wndclass);
  59.   }
  60.  
  61.   uSelector1 = uSelector2 = SELECTOROF((LPWORD)&uSelector1);
  62.   uSelector1 = AllocSelector (uSelector1);
  63.   uSelector2 = AllocSelector (uSelector2);
  64.  
  65.   hwnd = CreateDialog (hInstance, szAppName, 0, 0L);
  66.   ShowWindow (hwnd, nCmdShow);
  67.  
  68.   while (GetMessage (&msg,NULL,0,0))
  69.   {
  70.     TranslateMessage (&msg);
  71.     DispatchMessage (&msg);
  72.   }
  73.  
  74.   return   msg.wParam;
  75. }
  76.  
  77. long FAR PASCAL WndProc (HWND hwnd,WORD msg,WORD wParam,LONG lParam)
  78. {
  79. char              buffer[128];
  80. LPPAGE            ptabptr;
  81. int               tab1[] = {20,60,90,105,115,125,135,145};
  82. int               tab2[] = {75,125,190,255};
  83. char              control[80];
  84. int               index;
  85. static UINT       lbindex;
  86. int               pdir;
  87. static WPARAM     lbowner;
  88. static WORD       stopvm;
  89. DWORD             phys;
  90.  
  91.   switch (msg)
  92.   {
  93.     case WM_CREATE:
  94.       GateRegisterWindow (hwnd);
  95.       break;
  96.  
  97.     case WM_SHOWWINDOW:     /* prepare the VMM event list box */
  98.       SendMessage (GetDlgItem (hwnd, IDLB_EVENT), LB_RESETCONTENT, 0, 0L);
  99.       SendMessage (GetDlgItem (hwnd, IDLB_EVENT), LB_SETTABSTOPS, 4, (DWORD)(LPINT)tab2);
  100.       break;
  101.  
  102.     case WM_COMMAND:
  103.       switch (wParam)
  104.       {
  105.         case IDPB_PDIR:             /* page directory */
  106.           lbowner = wParam;
  107.           sysstruct.VMCount = 10;
  108.           GetSys (&sysstruct);      /* call RINGO */
  109.  
  110.           wsprintf (buffer,
  111.                    "Page Directory    Physical = %08lX   Linear = %08lX",
  112.                    sysstruct.SysCr.CR3R, sysstruct.SysCr.PDIRL);
  113.           SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  114.  
  115.           PageDirListBox (GetDlgItem (hwnd, IDLB_PDIR), buffer, 0);
  116.           break;
  117.  
  118.         case IDLB_PDIR:            /* page table */
  119.           if (HIWORD(lParam) == LBN_DBLCLK & lbowner == IDPB_PDIR)
  120.           {
  121.             lbowner = wParam;
  122.             lbindex = LOWORD(SendMessage (LOWORD(lParam), LB_GETCURSEL, 0, 0L));
  123.             if (lbindex < 2)
  124.               break;
  125.             pdir = LOWORD(SendMessage (LOWORD(lParam), LB_GETITEMDATA, lbindex, 0L));
  126.  
  127.             SetSelectorBase (uSelector1, sysstruct.SysCr.PDIRL);
  128.             SetSelectorLimit (uSelector1, P_SIZE);
  129.             ptabptr = (LPPAGE)MAKELP(uSelector1, 0) + pdir;
  130.  
  131.             SetSelectorBase (uSelector1,
  132.                      MapPhysToLinear (*ptabptr & PAGE_FRAME_ADS_MASK, P_SIZE));
  133.             SetSelectorLimit (uSelector1, P_SIZE);
  134.             ptabptr = (LPPAGE)MAKELP(uSelector1, 0);
  135.             wsprintf (buffer,"Page Table  %04X",pdir);
  136.             SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  137.             SendMessage (LOWORD(lParam), LB_RESETCONTENT, 0, 0L);
  138.             SendMessage (LOWORD(lParam), LB_SETTABSTOPS, 8, (DWORD)(LPINT)tab1);
  139.             wsprintf (buffer,"Entry\tLin Range\tPhys #\t  Attributes  and  VMM Type");
  140.             SendMessage (LOWORD(lParam), LB_ADDSTRING, 0, (LONG)(LPSTR)buffer);
  141.             wsprintf (buffer,"");
  142.             SendMessage (LOWORD(lParam), LB_ADDSTRING, 0, (LONG)(LPSTR)buffer);
  143.             for (index = 0; index < PTABLE_SIZE; index++,ptabptr++)
  144.               if ((phys = PageTable (buffer, ptabptr, index, pdir)) != 0xFFFFFFFF)
  145.               {
  146.                 lbindex = LOWORD(SendMessage (LOWORD(lParam), LB_ADDSTRING, 0, (LONG)(LPSTR)buffer));
  147.                 if (lbindex != LB_ERR && lbindex != LB_ERRSPACE)
  148.                   SendMessage (LOWORD(lParam), LB_SETITEMDATA, lbindex, phys);
  149.               }
  150.             SendMessage (LOWORD(lParam), LB_SETCURSEL, 0, 0L);
  151.           }
  152.           else if (HIWORD(lParam) == LBN_DBLCLK & lbowner == IDLB_PDIR)
  153.           {
  154.             lbowner = 0;
  155.             lbindex = LOWORD(SendMessage (LOWORD(lParam), LB_GETCURSEL, 0, 0L));
  156.             if (lbindex < 2)
  157.               break;
  158.             phys = SendMessage (LOWORD(lParam), LB_GETITEMDATA, lbindex, 0L);
  159.             wsprintf (buffer,"Virtual Addresses for the Physical Address %08lX",
  160.                                                   phys);
  161.             SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  162.             PhysListBox (LOWORD(lParam), buffer, phys);
  163.           }
  164.           break;
  165.  
  166.         case IDPB_GDT:              /* GDT */
  167.           lbowner = wParam;
  168.           GetSys (&sysstruct);
  169.  
  170.           wsprintf (buffer, "GDTBase = %08lX   Limit = %04X",
  171.                    sysstruct.SysGdt.GDTRB, sysstruct.SysGdt.GDTRL);
  172.           SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  173.  
  174.           GDTListBox (GetDlgItem (hwnd, IDLB_PDIR), buffer, 0);
  175.           break;
  176.  
  177.         case IDPB_LDT:              /* LDT */
  178.           lbowner = wParam;
  179.           GetSys (&sysstruct);
  180.  
  181.           wsprintf (buffer, "LDT Sel = %04X  Base = %08lX  Limit = %04X",
  182.                    sysstruct.SysLdt.LDTRS, sysstruct.SysLdt.LDTB,
  183.                    sysstruct.SysLdt.LDTSL);
  184.           SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  185.  
  186.           LDTListBox (GetDlgItem (hwnd, IDLB_PDIR), buffer, 0);
  187.           break;
  188.  
  189.         case IDPB_IDT:              /* IDT */
  190.           lbowner = wParam;
  191.           GetSys (&sysstruct);
  192.  
  193.           wsprintf (buffer, "IDTBase = %08lX   Limit = %04X",
  194.                    sysstruct.SysIdt.IDTRB, sysstruct.SysIdt.IDTRL);
  195.           SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  196.  
  197.           IDTListBox (GetDlgItem (hwnd, IDLB_PDIR), buffer, 0);
  198.           break;
  199.  
  200.         case IDPB_TASK:             /* TSS */
  201.           lbowner = wParam;
  202.           GetSys (&sysstruct);
  203.  
  204.           wsprintf (buffer, "TR = %04X   TSSBase = %08lX  TSSLimit = %04X",
  205.                    sysstruct.SysTss.TREG,sysstruct.SysTss.TSSB,
  206.                    sysstruct.SysTss.TSSL);
  207.           SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  208.  
  209.           TSSListBox (GetDlgItem (hwnd, IDLB_PDIR), buffer);
  210.           break;
  211.  
  212.         case IDPB_CRDR:             /* Control and Debug registers */
  213.           lbowner = wParam;
  214.           GetSys (&sysstruct);
  215.           wsprintf (buffer, "Control and Debug registers");
  216.           SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  217.           CRDRListBox (GetDlgItem (hwnd, IDLB_PDIR), buffer);
  218.           break;
  219.  
  220.         case IDPB_CLEAR:            /* clear the VMM Event list box */
  221.           SendMessage (GetDlgItem (hwnd, IDLB_EVENT), LB_RESETCONTENT, 0, 0L);
  222.           SendMessage (GetDlgItem (hwnd, IDLB_EVENT), LB_SETTABSTOPS, 4, (DWORD)(LPINT)tab2);
  223.           break;
  224.  
  225.         case IDPB_STOPVM:           /* 'DOS' button */
  226.           stopvm ^= 1;
  227.           NoDosBox (stopvm ? Create_VM : 0xffff);
  228.           wsprintf (buffer,"%s",stopvm?(LPSTR)"dos":(LPSTR)"DOS");
  229.           SetWindowText (LOWORD(lParam), buffer);
  230.           break;
  231.  
  232.         case IDPB_VXD:              /* VxD list */
  233.           lbowner = wParam;
  234.           GetSys (&sysstruct);
  235.           wsprintf (buffer,"VxD Root (VMM DDB pointer)  =   %08lX",
  236.                     sysstruct.VxDRoot);
  237.           SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  238.           VxDListBox (GetDlgItem (hwnd, IDLB_PDIR), buffer);
  239.           break;
  240.  
  241.         case IDPB_VM:               /* VM list */
  242.           lbowner = wParam;
  243.           sysstruct.VMCount = 10;
  244.           wsprintf (buffer,"VMM version %d.%d,  build revision %08ld,   Number of running VMs = %04d",
  245.                     HIBYTE(sysstruct.VMMVer), LOBYTE(sysstruct.VMMVer),
  246.                     sysstruct.VMMRev, (int)GetSys (&sysstruct));
  247.           SetWindowText (GetDlgItem (hwnd,IDS_HDR), buffer);
  248.           VMListBox (GetDlgItem (hwnd, IDLB_PDIR), buffer);
  249.           break;
  250.  
  251.         case IDPB_HELP:
  252.           MessageBox (hwnd,helpmsg,"GateView",MB_OK);
  253.           break;
  254.  
  255.         case IDPB_EXIT:
  256.           DestroyWindow (hwnd);
  257.           return 0;
  258.       }
  259.       break;
  260.  
  261.     /* RINGO sends us this message every time his Control Procedure gets hit */
  262.     case WM_USER + WM_RINGO:
  263.       LoadControlInfo (wParam,(LPMSGSTRUC)lParam,control);
  264.       wsprintf (buffer,"%s\tVM %08lX%s",(LPSTR)control_msg[wParam],
  265.                ((LPMSGSTRUC)lParam)->msg_VM,(LPSTR)control);
  266.       SendMessage (GetDlgItem (hwnd, IDLB_EVENT), LB_ADDSTRING, 0, (LONG)(LPSTR)buffer);
  267.       break;
  268.  
  269.     case WM_DESTROY:
  270.       GateUnregisterWindow (hwnd);
  271.       FreeSelector (uSelector1);
  272.       FreeSelector (uSelector2);
  273.       PostQuitMessage (0);
  274.       return 0;
  275.   }
  276.   return DefWindowProc (hwnd,msg,wParam,lParam);
  277. }
  278.  
  279. /* System_Control message */
  280. void LoadControlInfo (WORD event, LPMSGSTRUC msg, LPSTR buffer)
  281. {
  282.   switch (event)
  283.   {
  284.     case Set_Device_Focus:
  285.       wsprintf (buffer,"\tDevice  %08lX\tFunc %08lX", msg->msg_Param1,
  286.                                                       msg->msg_Param3);
  287.       break;
  288.  
  289.     case VM_Not_Executeable:
  290.       wsprintf (buffer, "\tFlags %08lX",msg->msg_Param1);
  291.       break;
  292.  
  293.     case Begin_PM_App:
  294.       wsprintf (buffer,"\t%s\tApp CB %08lX", (msg->msg_Param1 & BPA_32_Bit)?
  295.                (LPSTR)"32-bit":(LPSTR)"16-bit",
  296.                msg->msg_Param2);
  297.       break;
  298.  
  299.     case End_PM_App:
  300.       wsprintf (buffer,"\t\tApp CB %08lX",msg->msg_Param2);
  301.       break;
  302.  
  303.     case Close_VM_Notify:
  304.       wsprintf (buffer,"\tFlags %08lX",msg->msg_Param1);
  305.       break;
  306.  
  307.     case Power_Event:
  308.       wsprintf (buffer,"\tEvent Msg %08lX",msg->msg_Param3);
  309.       break;
  310.  
  311.     default:
  312.       lstrcpy (buffer,"");
  313.       break;
  314.   }
  315. }
  316.  
  317. /* dumps the content of Control and Debug registers */
  318. void CRDRListBox (HWND lbhwnd, LPSTR buffer)
  319. {
  320. int      tabs[] = {25,75,100};
  321.  
  322.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  323.   SendMessage (lbhwnd, LB_SETTABSTOPS, 3, (DWORD)(LPINT)tabs);
  324.  
  325.   wsprintf (buffer,"CR0 = \t%08lX\tDR0 = \t%08lX", sysstruct.SysCr.CR0R,
  326.                                                    sysstruct.SysDr.DR0R);
  327.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  328.   wsprintf (buffer,"CR2 = \t%08lX\tDR1 = \t%08lX", sysstruct.SysCr.CR2R,
  329.                                                    sysstruct.SysDr.DR1R);
  330.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  331.   wsprintf (buffer,"CR3 = \t%08lX\tDR2 = \t%08lX", sysstruct.SysCr.CR3R,
  332.                                                    sysstruct.SysDr.DR2R);
  333.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  334.   wsprintf (buffer,"\t\tDR3 = \t%08lX", sysstruct.SysDr.DR3R);
  335.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  336.   wsprintf (buffer,"\t\tDR6 = \t%08lX", sysstruct.SysDr.DR6R);
  337.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  338.   wsprintf (buffer,"\t\tDR7 = \t%08lX", sysstruct.SysDr.DR7R);
  339.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  340. }
  341.  
  342. /* print out the list of currently running Virtual Machines */
  343. /* their status flags, and documented parameters */
  344. void VMListBox (HWND lbhwnd, LPSTR buffer)
  345. {
  346. int      tabs[] = {40,80,120,160};
  347. LPVM     vmptr;
  348. int      vmcnt;
  349. int      fl;
  350.  
  351.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  352.   SendMessage (lbhwnd, LB_SETTABSTOPS, 4, (DWORD)(LPINT)tabs);
  353.  
  354.   wsprintf (buffer,"VM Handle\tStatus\tHigh Lin\tClient Ptr\tVM ID");
  355.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  356.   wsprintf (buffer,"");
  357.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  358.  
  359.   for (vmcnt=0;vmcnt<(int)sysstruct.VMCount;vmcnt++)
  360.   {
  361.     /* map VM control block */
  362.     SetSelectorBase (uSelector1, sysstruct.VMHndl[vmcnt]);
  363.     SetSelectorLimit (uSelector1, sizeof(VM));
  364.     vmptr = (LPVM)MAKELP(uSelector1,0);
  365.  
  366.     wsprintf (buffer,"%08lX\t%08lX\t%08lX\t%08lX\t%08lX",
  367.               sysstruct.VMHndl[vmcnt],
  368.               vmptr->CB_VM_Status,
  369.               vmptr->CB_High_Linear,
  370.               vmptr->CB_Client_Pointer,
  371.               vmptr->CB_VMID);
  372.     SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  373.  
  374.     /* dump CB_ flags */
  375.     for (fl = 0; fl < sizeof(CB_Flags)/sizeof(char *); fl++)
  376.       if (vmptr->CB_VM_Status & (1<<fl))
  377.       {
  378.         wsprintf (buffer,"\t%s", (LPSTR)CB_Flags[fl]);
  379.         SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  380.       }
  381.   }
  382. }
  383.  
  384. /* print out the list of installed Virtual Devices */
  385. /* and everything we can find in the Device Descriptor Block about them */
  386. void VxDListBox (HWND lbhwnd, LPSTR buffer)
  387. {
  388. int      tabs[] = {40,60,80,120,160,200,240,280};
  389. LPDDB    ddbptr;
  390. char     namebuf[9];
  391.  
  392.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  393.   SendMessage (lbhwnd, LB_SETTABSTOPS, 8, (DWORD)(LPINT)tabs);
  394.   wsprintf (buffer,"VxD Name\tID\tVer\tControl\tV86 API\tPM API\tSvc Tab\tSvc Count");
  395.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  396.   wsprintf (buffer,"");
  397.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  398.  
  399.   SetSelectorBase (uSelector1, sysstruct.VxDRoot);
  400.   SetSelectorLimit (uSelector1, sizeof(DDB));
  401.   ddbptr = (LPDDB)MAKELP(uSelector1, 0);
  402.  
  403.   /* walk the VxD list */
  404.   while (1)
  405.   {
  406.     lstrcpyn (namebuf,ddbptr->DDB_Name,sizeof(namebuf));
  407.     namebuf[8] = '\0';
  408.     wsprintf (buffer,"%s\t%04X\t%d.%d\t%08lX\t%08lX\t%08lX\t%08lX\t%08lX",
  409.              (LPSTR)namebuf,
  410.              ddbptr->DDB_Req_Device_Number,
  411.              ddbptr->DDB_Dev_Major_Version,
  412.              ddbptr->DDB_Dev_Minor_Version,
  413.              ddbptr->DDB_Control_Proc,
  414.              ddbptr->DDB_V86_API_Proc,
  415.              ddbptr->DDB_PM_API_Proc,
  416.              ddbptr->DDB_Service_Table_Ptr,
  417.              ddbptr->DDB_Service_Table_Size);
  418.     SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  419.  
  420.     if (ddbptr->DDB_Next == 0)
  421.       break;
  422.     SetSelectorBase (uSelector1, ddbptr->DDB_Next);
  423.     SetSelectorLimit (uSelector1, sizeof(DDB));
  424.     ddbptr = (LPDDB)MAKELP(uSelector1, 0);
  425.   }
  426. }
  427.  
  428. BOOL ParsePageEntry (LPPAGE lppage, LPPGMAP pgmap)
  429. {
  430.   pgmap->pgatr  = (WORD)*lppage;
  431.   pgmap->pgtype = pgmap->pgatr & PG_TYPE;
  432.   pgmap->pgphys = *lppage & PAGE_FRAME_ADS_MASK;
  433.  
  434.   return (*lppage != NULL);
  435. }
  436.  
  437. BOOL PageDir (LPSTR buff, LPPAGE lppage, int pdir)
  438. {
  439. PGMAP pgmap;
  440. DWORD rangestart = (DWORD)pdir;
  441. DWORD rangeend   = (DWORD)pdir;
  442. char  pgtype[40];
  443. char  vmpgtab[10];
  444. DWORD vmid;
  445.  
  446.   if (ParsePageEntry (lppage, &pgmap))
  447.   {
  448.     rangestart <<= 22;
  449.     rangeend   = rangestart | (LIN_PAGE | LIN_OFFSET);
  450.  
  451.     PrintPageType (&pgmap, pgtype);
  452.     if (vmid = GetPageTableVM (rangestart))
  453.       wsprintf (vmpgtab, "VM %d",vmid);
  454.     else
  455.       lstrcpy (vmpgtab,"");
  456.  
  457.     wsprintf (buff, "%x:\t%08lX\t%08lX\t%08lX - %08lX%s\t%s",
  458.               pdir,
  459.               pgmap.pgphys,
  460.               MapPhysToLinear (pgmap.pgphys, P_SIZE),
  461.               rangestart,
  462.               rangeend,
  463.               (LPSTR)pgtype,
  464.               (LPSTR)vmpgtab);
  465.     return TRUE;
  466.   }
  467.   return FALSE;
  468. }
  469.  
  470. DWORD PageTable (LPSTR buff, LPPAGE lppage, int ptab, int pdir)
  471. {
  472. PGMAP pgmap;
  473. char  pgtype[40]; /* Present Write Accessed User Dirty Type*/
  474.  
  475.   if (ParsePageEntry(lppage, &pgmap))
  476.   {
  477.     PrintPageType (&pgmap, pgtype);
  478.  
  479.     wsprintf (buff, "%X:\t%05lXxxx\t%lX%s",
  480.               ptab,
  481.               (DWORD)pdir << 10 | ptab,
  482.               pgmap.pgphys >> 12,
  483.               (LPSTR)pgtype);
  484.     return pgmap.pgphys;
  485.   }
  486.   return 0xFFFFFFFF;
  487. }
  488.  
  489. LPSTR PrintPageType (LPPGMAP entry, LPSTR pgtype)
  490. {
  491.   lstrcpy (pgtype, (entry->pgatr & P_PRES) ? "\t P" : "\tNP");
  492.   lstrcat (pgtype, (entry->pgatr & P_WRITE) ? "\tW" : "\t ");
  493.   lstrcat (pgtype, (entry->pgatr & P_ACC) ? "\tA" : "\t ");
  494.   lstrcat (pgtype, (entry->pgatr & P_USER) ? "\tU" : "\tS");
  495.   lstrcat (pgtype, (entry->pgatr & P_DIRTY) ? "\tD" : "\t ");
  496.  
  497.   switch (entry->pgtype)
  498.   {
  499.     case PgT_VM:
  500.       lstrcat (pgtype, "\tVM");
  501.       break;
  502.  
  503.     case PgT_SYS:
  504.       lstrcat (pgtype, "\tSystem");
  505.       break;
  506.  
  507.     case PgT_HOOKED:
  508.       lstrcat (pgtype, "\tHooked");
  509.       break;
  510.  
  511.     case PgT_RESERVED1:
  512.       lstrcat (pgtype, "\tReserved1");
  513.       break;
  514.  
  515.     case PgT_RESERVED2:
  516.       lstrcat (pgtype, "\tReserved2");
  517.       break;
  518.  
  519.     case PgT_PRIVATE:
  520.       lstrcat (pgtype, "\tPrivate");
  521.       break;
  522.  
  523.     case PgT_RELOCK:
  524.       lstrcat (pgtype, "\tRelock");
  525.       break;
  526.  
  527.     case PgT_INSTANCE:
  528.       lstrcat (pgtype, "\tInstance");
  529.       break;
  530.   }
  531.   return (pgtype);
  532. }
  533.  
  534. /* Page Directory dump */
  535. void PageDirListBox (HWND lbhwnd, LPSTR buffer, UINT pdir)
  536. {
  537. UINT     entry, lbind;
  538. int      tabs[] = {20,60,100,164,174,184,194,204,214};
  539. LPPAGE   ptabptr;
  540.  
  541.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  542.   SendMessage (lbhwnd, LB_SETTABSTOPS, 9, (DWORD)(LPINT)tabs);
  543.   wsprintf (buffer,"PTab\tPhysical\tLinear\tRange\t\tFlags and VMM Type\tOwner");
  544.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  545.   wsprintf (buffer,"");
  546.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  547.  
  548.   SetSelectorBase (uSelector1, sysstruct.SysCr.PDIRL);
  549.   SetSelectorLimit (uSelector1, P_SIZE);
  550.   ptabptr = (LPPAGE)MAKELP(uSelector1, 0);
  551.  
  552.   /* walk the Page Directory */
  553.   for (entry = 0; entry < PTABLE_SIZE; entry++,ptabptr++)
  554.     if (PageDir (buffer, ptabptr, entry))
  555.     {
  556.       lbind = LOWORD(SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer));
  557.       if (lbind != LB_ERR && lbind != LB_ERRSPACE)
  558.         SendMessage (lbhwnd, LB_SETITEMDATA, lbind, (DWORD)entry);
  559.     }
  560.   SendMessage (lbhwnd, LB_SETCURSEL, pdir, 0L);
  561. }
  562.  
  563. BYTE ParseDescriptor (LPSEGDESCRIPTOR descptr, LPSEGDESCMAP descmap)
  564. {
  565.   descmap->base = MAKEBASE(descptr->Seg_Desc_Base_0_15,
  566.                            descptr->Seg_Desc_Base_16_23,
  567.                            descptr->Seg_Desc_Base_24_31);
  568.   descmap->limit = MAKELIMIT(descptr->Seg_Desc_Limit_0_15,
  569.                              descptr->Seg_Desc_Gran_Byte);
  570.   descmap->type = descptr->Seg_Desc_Access_Right;
  571.   descmap->dpl = (descptr->Seg_Desc_Access_Right & D_DPL3) >> 5;
  572.   descmap->gran = descptr->Seg_Desc_Gran_Byte;
  573.   return (descmap->type);
  574. }
  575.  
  576. void PrintDescriptor (LPSTR buff, LPSEGDESCRIPTOR GDTSel, int index, BYTE tab)
  577. {
  578. #define  TASKGATE 1
  579. #define  CALLGATE 2
  580. #define  TRAPGATE 4
  581. #define  INTGATE  8
  582.  
  583. char     dsctype[20];
  584. char     attribute[40];
  585. LPSEGDESCRIPTOR ptr = GDTSel + index;
  586. BYTE     system = 0;
  587. SEGDESCMAP descmap;
  588.  
  589.   if (ParseDescriptor (ptr, &descmap) & D_PRES)
  590.     lstrcpy (attribute, "\tP");
  591.   else
  592.     lstrcpy (attribute, "\tNP");
  593.  
  594.   if (descmap.gran & D_GRAN_PAGE)
  595.   {
  596.     descmap.limit *= P_SIZE;
  597.     descmap.limit += P_SIZE - 1;
  598.   }
  599.  
  600.   if (descmap.type & D_SEG)                    /* segment descriptor */
  601.   {
  602.     if (descmap.type & D_CODE)                /* code segment */
  603.     {
  604.       lstrcpy (dsctype, "Code");
  605.  
  606.       if (descmap.type & D_C)
  607.         lstrcat (attribute, "\tC");   /* conforming */
  608.       else
  609.         lstrcat (attribute, "\t");    /* conforming */
  610.  
  611.       if (descmap.type & D_RX)
  612.         lstrcat (attribute, "\tRE");    /* readable, executeable */
  613.       else
  614.         lstrcat (attribute, "\tE");     /* executeable */
  615.     }
  616.     else                      /* data segment */
  617.     {
  618.       lstrcpy (dsctype, "Data");
  619.  
  620.       if (descmap.type & D_E)
  621.         lstrcat (attribute, "\tEX");
  622.       else
  623.         lstrcat (attribute, "\t");
  624.  
  625.       if (descmap.type & D_W)
  626.         lstrcat (attribute, "\tRW");
  627.       else
  628.         lstrcat (attribute, "\tR");
  629.     }
  630.     if (descmap.type & D_ACCESSED)
  631.       lstrcat (attribute, "\tA");
  632.  
  633.     if (descmap.gran & D_DEF32)
  634.       lstrcat (dsctype, "32");
  635.     else
  636.       lstrcat (dsctype, "16");
  637.   }
  638.   else                                   /* system descriptor */
  639.   {
  640.     switch (descmap.type & DESC_MASK)
  641.     {
  642.       case DESC_TYPE_286_TSS:
  643.         lstrcpy (dsctype, "TSS16");
  644.         break;
  645.       case DESC_TYPE_LDT:
  646.         lstrcpy (dsctype, "LDT");
  647.         break;
  648.       case DESC_TYPE_BUSY_286_TSS:
  649.         lstrcpy (dsctype, "TSS16");
  650.         lstrcat (attribute, "\tB");
  651.         break;
  652.       case DESC_TYPE_286_CALL_GATE:
  653.         lstrcpy (dsctype, "CallG16");
  654.         system |= CALLGATE;
  655.         break;
  656.       case DESC_TYPE_TASK_GATE:
  657.         lstrcpy (dsctype, "TaskG");
  658.         system |= TASKGATE;
  659.         break;
  660.       case DESC_TYPE_286_INT_GATE:
  661.         lstrcpy (dsctype, "IntG16");
  662.         system |= INTGATE;
  663.         break;
  664.       case DESC_TYPE_286_TRAP_GATE:
  665.         lstrcpy (dsctype, "TrapG16");
  666.         system |= TRAPGATE;
  667.         break;
  668.       case DESC_TYPE_386_TSS:
  669.         lstrcpy (dsctype, "TSS32");
  670.         break;
  671.       case DESC_TYPE_BUSY_386_TSS:
  672.         lstrcpy (dsctype, "TSS32");
  673.         lstrcat (attribute, "\tB");
  674.         break;
  675.       case DESC_TYPE_386_CALL_GATE:
  676.         lstrcpy (dsctype, "CallG32");
  677.         system |= CALLGATE;
  678.         break;
  679.       case DESC_TYPE_386_INT_GATE:
  680.         lstrcpy (dsctype, "IntG32");
  681.         system |= INTGATE;
  682.         break;
  683.       case DESC_TYPE_386_TRAP_GATE:
  684.         lstrcpy (dsctype, "TrapG32");
  685.         system |= TRAPGATE;
  686.         break;
  687.  
  688.       default:
  689.         lstrcpy (dsctype, "Rsrved");
  690.         break;
  691.     }
  692.   }
  693.  
  694.   if (!system)
  695.     wsprintf (buff,"%x\t%s\t%08lX\t%08lX\t%x%s",
  696.               (index * 8) | descmap.dpl | tab,
  697.               (LPSTR)dsctype,
  698.               descmap.base, descmap.limit, descmap.dpl,
  699.               (LPSTR)attribute);
  700.   else if (system & TASKGATE)
  701.     wsprintf (buff,"%x\t%s\t%X\t\t%x%s",
  702.               (index * 8) | descmap.dpl | tab,
  703.               (LPSTR)dsctype,
  704.               ((LPCALLGATEDESCRPT)ptr)->Selector, descmap.dpl,
  705.               (LPSTR)attribute);
  706.   else if (system & CALLGATE)
  707.     wsprintf (buff,"%x\t%s\t%04X\t%08lX\t%x%s",
  708.               (index * 8) | descmap.dpl | tab,
  709.               (LPSTR)dsctype,
  710.               ((LPCALLGATEDESCRPT)ptr)->Selector,
  711.               MAKELONG(((LPCALLGATEDESCRPT)ptr)->Offset_O_15,
  712.                        ((LPCALLGATEDESCRPT)ptr)->Offset_16_31),
  713.               descmap.dpl,
  714.               (LPSTR)attribute);
  715.   else     /* interrupt and trap gates */
  716.     wsprintf (buff,"%x\t%s\t%04X\t%08lX\t%x%s",
  717.               index,
  718.               (LPSTR)dsctype,
  719.               ((LPCALLGATEDESCRPT)ptr)->Selector,
  720.               MAKELONG(((LPCALLGATEDESCRPT)ptr)->Offset_O_15,
  721.                        ((LPCALLGATEDESCRPT)ptr)->Offset_16_31),
  722.               descmap.dpl,
  723.               (LPSTR)attribute);
  724. }
  725.  
  726. /* dump the Global Descriptor Table */
  727. void GDTListBox (HWND lbhwnd, LPSTR buffer, UINT entry)
  728. {
  729. LPSEGDESCRIPTOR gdtptr;
  730. int            index;
  731. int            tabs[] = {30,60,100,145,170,180,190,205};
  732.  
  733.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  734.   SendMessage (lbhwnd, LB_SETTABSTOPS, 8, (DWORD)(LPINT)tabs);
  735.   wsprintf (buffer,"Selector\tType\tBase\tLimit\tDPL\tAccess Rights");
  736.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  737.   wsprintf (buffer,"");
  738.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  739.   SetSelectorBase (uSelector1, sysstruct.SysGdt.GDTRB);
  740.   SetSelectorLimit (uSelector1, sysstruct.SysGdt.GDTRL);
  741.  
  742.   gdtptr = (LPSEGDESCRIPTOR)MAKELP(uSelector1, 0);
  743.   /* walk the GDT */
  744.   for (index = 1; index < (int)(sysstruct.SysGdt.GDTRL + 1) / 8; index++)
  745.   {
  746.     PrintDescriptor (buffer, gdtptr, index, 0);
  747.     SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  748.   }
  749.   SendMessage (lbhwnd, LB_SETCURSEL, entry, 0L);
  750. }
  751.  
  752. /* dumps the Local Descriptor Table */
  753. void LDTListBox (HWND lbhwnd, LPSTR buffer, UINT entry)
  754. {
  755. LPSEGDESCRIPTOR ldtptr;
  756. int            index;
  757. int            tabs[] = {30,60,100,145,160,175,185,200};
  758.  
  759.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  760.   SendMessage (lbhwnd, LB_SETTABSTOPS, 8, (DWORD)(LPINT)tabs);
  761.   wsprintf (buffer,"Sel\tType\tBase\tLimit\tDPL\tAccess Rights");
  762.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  763.   wsprintf (buffer,"");
  764.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  765.  
  766.   SetSelectorBase (uSelector1, sysstruct.SysLdt.LDTB);
  767.   SetSelectorLimit (uSelector1, sysstruct.SysLdt.LDTSL);
  768.  
  769.   ldtptr = (LPSEGDESCRIPTOR)MAKELP(uSelector1, 0);
  770.   /* walk the LDT */
  771.   for (index = 0; index < (int)(sysstruct.SysLdt.LDTSL + 1) / 8; index++)
  772.   {
  773.     PrintDescriptor (buffer, ldtptr, index, TABLE_MASK);
  774.     SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  775.   }
  776.   SendMessage (lbhwnd, WM_SETREDRAW, TRUE, 0L);
  777.   SendMessage (lbhwnd, LB_SETCURSEL, entry, 0L);
  778. }
  779.  
  780. /* dumps the Interrupt Descriptor Tanle */
  781. void IDTListBox (HWND lbhwnd, LPSTR buffer, UINT entry)
  782. {
  783. LPSEGDESCRIPTOR gdtptr;
  784. int            index;
  785. int            tabs[] = {30,70,100,150,170,185,195,210};
  786.  
  787.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  788.   SendMessage (lbhwnd, LB_SETTABSTOPS, 8, (DWORD)(LPINT)tabs);
  789.   wsprintf (buffer,"Sel\tType\tBase\tLimit\tDPL\tAccess Rights");
  790.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  791.   wsprintf (buffer,"");
  792.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  793.   SetSelectorBase (uSelector1, sysstruct.SysIdt.IDTRB);
  794.   SetSelectorLimit (uSelector1, sysstruct.SysIdt.IDTRL);
  795.  
  796.   gdtptr = (LPSEGDESCRIPTOR)MAKELP(uSelector1, 0);
  797.   /* walk the IDT */
  798.   for (index = 0; index < (int)(sysstruct.SysIdt.IDTRL + 1) / 8; index++)
  799.   {
  800.     PrintDescriptor (buffer, gdtptr, index, 0);
  801.     SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  802.   }
  803.   SendMessage (lbhwnd, LB_SETCURSEL, entry, 0L);
  804. }
  805.  
  806. /* dumps the Task State Segment (never changes in Windows)*/
  807. void TSSListBox (HWND lbhwnd, LPSTR buffer)
  808. {
  809. LPTSS_386 tssptr;
  810. int   tabs[] = {25,50,75,100,125,150,175,200,225,250,275};
  811.  
  812.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  813.   SendMessage (lbhwnd, LB_SETTABSTOPS, 11, (DWORD)(LPINT)tabs);
  814.   SetSelectorBase (uSelector1, sysstruct.SysTss.TSSB);
  815.   SetSelectorLimit (uSelector1, sysstruct.SysTss.TSSL);
  816.  
  817.   tssptr = (LPTSS_386)MAKELP(uSelector1, 0);
  818.  
  819.   wsprintf (buffer,"GS = \t%04X\tFS = \t%04X\tDS = \t%04X\tSS = \t%04X\tCS = \t%04X\tES = \t%04X",
  820.             tssptr->TSS_gs,
  821.             tssptr->TSS_fs,
  822.             tssptr->TSS_ds,
  823.             tssptr->TSS_ss,
  824.             tssptr->TSS_cs,
  825.             tssptr->TSS_es);
  826.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  827.   wsprintf (buffer,"LDT = \t%04X\tCR3 = \t%08lX",
  828.             tssptr->TSS_LDTR,
  829.             tssptr->TSS_cr3);
  830.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  831.   wsprintf (buffer,"EAX = \t%08lX\tEBX = \t%08lX\tECX = \t%08lX\tEDX = \t%08lX",
  832.             tssptr->TSS_eax,
  833.             tssptr->TSS_ebx,
  834.             tssptr->TSS_ecx,
  835.             tssptr->TSS_edx);
  836.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  837.   wsprintf (buffer,"ESI = \t%08lX\tEDI = \t%08lX\tEBP = \t%08lX\tESP = \t%08lX",
  838.             tssptr->TSS_esi,
  839.             tssptr->TSS_edi,
  840.             tssptr->TSS_ebp,
  841.             tssptr->TSS_esp);
  842.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  843.   wsprintf (buffer,"EIP = \t%08lX\tEFl = \t%08lX",
  844.             tssptr->TSS_eip,
  845.             tssptr->TSS_EFlags);
  846.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  847.   wsprintf (buffer,"SS0 = %04X : %08lX     SS1 = %04X : %08lX    SS2 = %04X : %08lX",
  848.             tssptr->TSS_ss0, tssptr->TSS_esp0,
  849.             tssptr->TSS_ss1, tssptr->TSS_esp1,
  850.             tssptr->TSS_ss2, tssptr->TSS_esp2);
  851.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  852. }
  853.  
  854. BOOL IsPageEntryPhys (LPPAGE lppage, DWORD phys, LPPGMAP pgmap)
  855. {
  856.    ParsePageEntry (lppage, pgmap);
  857.    return (pgmap->pgatr & P_PRES && pgmap->pgphys == phys);
  858. }
  859.  
  860.  
  861. void PhysListBox (HWND lbhwnd, LPSTR buffer, DWORD physical)
  862. {
  863. LPPAGE pdirptr, ptabptr;
  864. UINT   pdir, ptab;
  865. UINT   sel1,sel2;
  866. PGMAP  pgmap;
  867. char   pgtype[40];
  868. int    tab[] = {50,80,110,120,130,140,150,170,210};
  869. char   vmpgtab[10];
  870. DWORD  vmid;
  871. DWORD  linear;
  872.  
  873.   sel1 = sel2 = SELECTOROF((LPWORD)&uSelector1);
  874.   sel1 = AllocSelector (sel1);
  875.   sel2 = AllocSelector (sel2);
  876.   SendMessage (lbhwnd, LB_RESETCONTENT, 0, 0L);
  877.   SendMessage (lbhwnd, LB_SETTABSTOPS, 9, (DWORD)(LPINT)tab);
  878.  
  879.   SetSelectorBase (sel1, sysstruct.SysCr.PDIRL);
  880.   SetSelectorLimit (sel1, P_SIZE);
  881.   pdirptr = (LPPAGE)MAKELP(sel1, 0);
  882.  
  883.   wsprintf (buffer, "Linear\tPDir\tPTab\tAttributes and VMM types\tOwner");
  884.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  885.   wsprintf (buffer, "");
  886.   SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  887.   for (pdir = 0; pdir < PTABLE_SIZE; pdir++)
  888.     if (*(pdirptr + pdir))
  889.     {
  890.       SetSelectorBase (sel2, MapPhysToLinear((*(pdirptr + pdir)) & PAGE_FRAME_ADS_MASK, 4096));
  891.       SetSelectorLimit (sel2, P_SIZE);
  892.       ptabptr = (LPPAGE)MAKELP(sel2, 0);
  893.       for (ptab = 0; ptab < PTABLE_SIZE; ptab++)
  894.         if (IsPageEntryPhys (ptabptr + ptab, physical & PAGE_FRAME_ADS_MASK,&pgmap))
  895.         {
  896.           PrintPageType (&pgmap, pgtype);
  897.           linear = MAKELIN(pdir,ptab,0);
  898.           if (vmid = GetPageTableVM (linear & LIN_DIR))
  899.             wsprintf (vmpgtab, "VM %d",vmid);
  900.           else
  901.             lstrcpy (vmpgtab,"");
  902.           wsprintf (buffer, "%08lX\t%04X\t%04X%s\t%s", linear, pdir, ptab,
  903.                                                          (LPSTR)pgtype,
  904.                                                          (LPSTR)vmpgtab);
  905.           SendMessage (lbhwnd, LB_ADDSTRING, 0, (LONG)buffer);
  906.         }
  907.     }
  908.   SendMessage (lbhwnd, LB_SETCURSEL, 0, 0L);
  909.   FreeSelector (sel1);
  910.   FreeSelector (sel2);
  911. }
  912.  
  913. DWORD GetPageTableVM (DWORD linear)
  914. {
  915. int   vmcnt;
  916. LPVM  vmptr;
  917. UINT  sel;
  918. DWORD vmid = 0;
  919.  
  920.   sel = SELECTOROF((LPWORD)&uSelector1);
  921.   sel = AllocSelector (sel);
  922.   for (vmcnt=0;vmcnt<(int)sysstruct.VMCount;vmcnt++)
  923.   {
  924.     /* map VM control block */
  925.     SetSelectorBase (sel, sysstruct.VMHndl[vmcnt]);
  926.     SetSelectorLimit (sel, sizeof(VM));
  927.     vmptr = (LPVM)MAKELP(sel,0);
  928.  
  929.     if (vmptr->CB_High_Linear == linear)
  930.     {
  931.       vmid = vmptr->CB_VMID;
  932.         break;
  933.     }
  934.   }
  935.   FreeSelector (sel);
  936.   return vmid;
  937. }
  938.