开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 钩子与API截获 > 查看源码
APISpy32.cpp
资源名称：apispy32.zip　[点击查看]
上传用户：tzh4061
上传日期：2007-01-08
资源大小：309k
文件大小：27k
源码类别：

钩子与API截获

开发平台：

Visual C++

APISpy32.cpp：源码内容
  1. // ----------------------------------- //
  2. //            APISpy32 v2.0            //
  3. //     Copyright 1999 Yariv Kaplan     //
  4. //          WWW.INTERNALS.COM          //
  5. // ----------------------------------- //
  7. #include <windows.h>
  8. #include <stdio.h>
  9. #include <commctrl.h>
  10. #include "resource.h"
  11. #include "..dlllogapi.h"
  12. #include "htmlhelp.h"
  13. #include "apispy9x.h"
  14. #include "apispynt.h"
  15. #include "general.h"
  16. #include "errors.h"
  17. #include "apispy32.h"
  19. // Event handles
  21. HANDLE hOverflowEvent = NULL;
  22. HANDLE hLogEvent = NULL;
  23. HANDLE hInjectThreadExitEvent = NULL;
  24. HANDLE hLogThreadExitEvent = NULL;
  26. // Thread handles
  28. HANDLE hLogThread = NULL;
  29. HANDLE hInjectDLLThread = NULL;
  31. // Mutex handles
  33. HANDLE hListViewMutex = NULL;
  34. HANDLE hLogMutex = NULL;
  36. // Flags
  38. bool IsNT = false;
  39. bool WindowOnTop = false;
  40. bool AutoScroll = true;
  41. bool CaptureEvents = true;
  43. DWORD dwListViewRow = 0;
  44. HANDLE hMailslot = NULL;
  45. HWND hWndMain;
  46. HWND hWndToolbar;
  47. HWND hWndListView;
  48. HINSTANCE hInst;
  49. DWORD dwHelpCookie;
  50. bool DeletingListView = false;
  52. // Exported functions 
  54. GETLOGPARAMETERS_PROC pGetLogParameters;
  55. SETCAPTUREEVENTSFLAG_PROC pSetCaptureEventsFlag;
  56. ADVANCETONEXTLOGENTRY_PROC pAdvanceToNextLogEntry;
  58. // Toolbar buttons
  60. TBBUTTON tbButtons[] = {
  61. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  62. { 0, IDM_SAVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  63. { 2, IDM_CAPTURE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  64. { 4, IDM_AUTOSCROLL, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  65. { 5, IDM_CLEAR, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  66. };
  68. TBBUTTON tbButtonsOld[] = {
  69. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  70. { 0, IDM_SAVE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  71. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  72. { 2, IDM_CAPTURE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  73. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  74. { 4, IDM_AUTOSCROLL, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0},
  75. { 0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, 0L, 0},
  76. { 5, IDM_CLEAR, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0L, 0}
  77. };  
  79. // Forward declarations
  81. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  82. bool ShutdownAPISpy32();
  85. void ErrorHandler(PSTR pszErrorMsg, bool FatalFlag)
  86. {
  87.   char szErrorMsg[256];
  89.   if (FatalFlag)
  90.   {
  91.     strcpy(szErrorMsg, pszErrorMsg);
  92.     strcat(szErrorMsg, ERRORMSG);
  94.     MessageBox(hWndMain, szErrorMsg, "APISpy32", MB_OK | MB_ICONERROR);
  95.     ShutdownAPISpy32();
  96.     ExitProcess(0);
  97.   }
  98.   else
  99.     MessageBox(hWndMain, pszErrorMsg, "APISpy32", MB_OK | MB_ICONWARNING);
  100. }
  103. void InitApplication(HINSTANCE hInstance)
  104. {
  105.   WNDCLASS wc;
  106.   ATOM WndClassAtom;
  108.   wc.style = 0;
  109.   wc.lpfnWndProc = (WNDPROC)MainWndProc;
  110.   wc.cbClsExtra = 0;
  111.   wc.cbWndExtra = 0;
  112.   wc.hInstance = hInstance;
  113.   wc.hIcon = LoadIcon(hInstance, "ICON");
  114.   wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  115.   wc.hbrBackground = (HBRUSH)(COLOR_INACTIVEBORDER + 1);
  116.   wc.lpszMenuName = "LISTMENU";
  117.   wc.lpszClassName = "APISpy32Class";
  119.   WndClassAtom = RegisterClass(&wc);
  121.   if (WndClassAtom == 0)
  122.     ErrorHandler(ERROR_REGISTERCLASS, true);
  123. }
  126. bool GetWindowsVersion()
  127. {
  128.   OSVERSIONINFO VersionInfo;
  129.   BOOL Result;
  131.   VersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  133.   Result = GetVersionEx(&VersionInfo);
  135.   if (Result == FALSE)
  136.     return false;
  138.   if (VersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
  139.     IsNT = true;
  141.   return true;
  142. }
  145. void ReadSettings()
  146. {
  147.   HKEY hKey;
  148.   DWORD dwParamSize;
  150.   Settings.dwLeft = CW_USEDEFAULT;
  151.   Settings.dwTop = CW_USEDEFAULT;
  152.   Settings.dwWidth = CW_USEDEFAULT;
  153.   Settings.dwHeight = CW_USEDEFAULT;
  154.   Settings.WindowOnTop = false;
  155.   Settings.Maximized = false;
  157.   Settings.dwLVColumnWidth[0] = COLUMN_WIDTH1;
  158.   Settings.dwLVColumnWidth[1] = COLUMN_WIDTH2;
  159.   Settings.dwLVColumnWidth[2] = COLUMN_WIDTH3;
  160.   Settings.dwLVColumnWidth[3] = COLUMN_WIDTH4;
  162.   RegCreateKey(HKEY_CURRENT_USER, APISPY32_REG_KEY, &hKey);
  164.   dwParamSize = sizeof(Settings);
  166.   RegQueryValueEx(hKey, "Settings", NULL, NULL, (LPBYTE)&Settings, &dwParamSize);
  168.   RegCloseKey(hKey);
  170.   WindowOnTop = Settings.WindowOnTop;  
  171. }
  174. bool WriteSettings(HWND hWnd)
  175. {
  176.   HKEY hKey;
  177.   RECT Rect;
  178.   LONG Result;
  179.   DWORD dwIndex;
  181.   Result = GetWindowRect(hWnd, &Rect);
  183.   if (Result == 0)
  184.     return false;
  186.   if (!IsIconic(hWnd))
  187.   {
  188.     Settings.dwLeft = Rect.left;
  189.     Settings.dwTop = Rect.top;
  190.     Settings.dwWidth = Rect.right - Rect.left;
  191.     Settings.dwHeight = Rect.bottom - Rect.top;
  192.   }
  194.   Settings.WindowOnTop = WindowOnTop;
  195.   Settings.Maximized = IsZoomed(hWnd);
  197.   for (dwIndex = 0; dwIndex < NUMCOLUMNS; dwIndex++)
  198.     Settings.dwLVColumnWidth[dwIndex] = ListView_GetColumnWidth(hWndListView, dwIndex);
  200.   Result = RegOpenKey(HKEY_CURRENT_USER, "Software\Internals\APISpy32", &hKey);
  202.   if (Result != ERROR_SUCCESS)
  203.     return false;
  205.   Result = RegSetValueEx(hKey, "Settings", 0, REG_BINARY, (LPBYTE)&Settings, sizeof(Settings));
  207.   if (Result != ERROR_SUCCESS)
  208.     return false;
  210.   Result = RegCloseKey(hKey);
  212.   if (Result != ERROR_SUCCESS)
  213.     return false;
  215.   return true;
  216. }
  219. HWND InitInstance(HINSTANCE hInstance, int nCmdShow)
  220. {
  222.   ReadSettings();
  224.   hInst = hInstance;
  226.   hWndMain = CreateWindow("APISpy32Class", "APISpy32 - http://www.internals.com", WS_OVERLAPPEDWINDOW, Settings.dwLeft, Settings.dwTop, Settings.dwWidth, Settings.dwHeight, NULL, NULL, hInstance, NULL);
  228.   if (hWndMain == NULL)
  229.     return NULL;
  231.   ShowWindow(hWndMain, nCmdShow);
  232.   UpdateWindow(hWndMain);
  234.   if (Settings.Maximized)
  235.     ShowWindow(hWndMain, SW_SHOWMAXIMIZED);
  237.   if (WindowOnTop)
  238.   {
  239.     SetWindowPos(hWndMain, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
  240.     CheckMenuItem(GetMenu(hWndMain), IDM_ONTOP, MF_BYCOMMAND | (WindowOnTop ? MF_CHECKED:MF_UNCHECKED));
  241.   }
  243.   return hWndMain;
  244. }
  247. HWND CreateListView(HWND hWndParent)
  248. {
  249.   RECT Rect;
  250.   BOOL Result;
  251.   LV_COLUMN LVColumn;
  252.   DWORD dwIndex;
  254.   struct tagListViewColumn
  255.   {
  256.     PSTR pszText;
  257.     DWORD dwWidth;
  258.   }ListViewColumn[] =
  259.   
  260.   {
  261.     {"Process",      COLUMN_WIDTH1},
  262.     {"API",          COLUMN_WIDTH2},
  263.     {"Return Value", COLUMN_WIDTH3},
  264.     {"Origin",       COLUMN_WIDTH4}
  265.   };
  266.   
  267.   InitCommonControls();
  269.   for (dwIndex = 0; dwIndex < NUMCOLUMNS; dwIndex++)
  270.     ListViewColumn[dwIndex].dwWidth = Settings.dwLVColumnWidth[dwIndex];
  272.   Result = GetClientRect(hWndParent, &Rect);
  274.   if (Result == FALSE)
  275.     return NULL;
  277.   hWndListView = CreateWindowEx(0L, WC_LISTVIEW, "", WS_VISIBLE | WS_CHILD | WS_BORDER | LVS_REPORT | LVS_SINGLESEL, 0, TOOLBARHEIGHT, Rect.right - Rect.left, Rect.bottom - Rect.top - TOOLBARHEIGHT, hWndParent, (HMENU)ID_LIST, hInst, NULL);
  279.   if (hWndListView == NULL)
  280.     return NULL;
  282.   LVColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  283.   LVColumn.fmt = LVCFMT_LEFT;
  285.   for (dwIndex = 0; dwIndex < sizeof(ListViewColumn) / sizeof(ListViewColumn[0]); dwIndex++)
  286.   {
  287.     LVColumn.iSubItem = dwIndex;
  288.     LVColumn.cx = ListViewColumn[dwIndex].dwWidth;
  289.     LVColumn.pszText = ListViewColumn[dwIndex].pszText;
  290.     
  291.     if (ListView_InsertColumn(hWndListView, dwIndex, &LVColumn) == -1)
  292.       return NULL;
  293.   }
  295.   SendMessage(hWndListView, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
  297.   return hWndListView;
  298. }
  301. DWORD GetDLLVersion(PSTR pszDLLName)
  302. {
  303.   HRESULT hResult;
  304.   DWORD dwVersion;
  305.   HINSTANCE hInstDll;
  306.   DLLVERSIONINFO DllVersionInfo;
  307.   DLLGETVERSIONPROC pDllGetVersion;
  310.   hInstDll = LoadLibrary(pszDLLName);
  312.   if (hInstDll == NULL)
  313.     return 0;
  315.   pDllGetVersion = (DLLGETVERSIONPROC)GetProcAddress(hInstDll, "DllGetVersion");
  317.   if (pDllGetVersion)
  318.   {
  319.     ZeroMemory(&DllVersionInfo, sizeof(DllVersionInfo));
  321.     DllVersionInfo.cbSize = sizeof(DllVersionInfo);
  323.     hResult = (*pDllGetVersion)(&DllVersionInfo);
  325.     if (SUCCEEDED(hResult))
  326.       dwVersion = PACKVERSION(DllVersionInfo.dwMajorVersion, DllVersionInfo.dwMinorVersion);
  327.   }
  329.   FreeLibrary(hInstDll);
  331.   return dwVersion;
  332. }
  335. DWORD SplitItems(PSTR pszItems, char *pItems[])
  336. {
  337.   DWORD dwItemCount = 0;
  339.   pszItems = strtok(pszItems, ";");
  341.   while (pszItems)
  342.   {
  343.     pItems[dwItemCount] = pszItems;
  345.     dwItemCount++;
  347.     pszItems = strtok(NULL, ";");
  348.   }
  350.   return dwItemCount;
  351. }
  354. void ListView_Append(PSTR pszItems)
  355. {
  356.   char *pItems[NUMCOLUMNS];
  357.   DWORD dwItemCount;
  358.   LVITEM LVItem;
  359.   DWORD dwIndex;
  361.   dwItemCount = SplitItems(pszItems, pItems);
  363.   LVItem.mask = LVIF_TEXT;
  364.   LVItem.iItem = dwListViewRow;
  365.   LVItem.iSubItem = 0;
  366.   LVItem.pszText = pItems[0];
  367.   LVItem.cchTextMax = strlen(pItems[0] + 1);
  368.   ListView_InsertItem(hWndListView, &LVItem);
  370.   if (AutoScroll)
  371.     ListView_EnsureVisible(hWndListView, ListView_GetItemCount(hWndListView) - 1, FALSE);
  373.   if (dwItemCount > 1)
  374.     for (dwIndex = 0; dwIndex < dwItemCount - 1; dwIndex++)
  375.       ListView_SetItemText(hWndListView, dwListViewRow, dwIndex + 1, pItems[dwIndex + 1]);
  377.   dwListViewRow++;
  378. }
  381. LRESULT CALLBACK AboutBoxWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  382. {
  383.   switch (uMsg)
  384.   {
  385.     case WM_INITDIALOG:
  387.       return TRUE;
  389.     break;
  391.     case WM_COMMAND:
  393.       if (LOWORD(wParam) == IDOK)
  394.       {
  395.         EndDialog(hWnd, TRUE);
  397.         return TRUE;
  398.       }
  400.     break;
  402.     case WM_CLOSE:
  404.       EndDialog(hWnd, TRUE);
  406.       return TRUE;
  408.     break;
  409.   }
  411.   return FALSE;
  412. }
  415. bool OutputLogBuffer()
  416. {
  417.   bool Result;
  418.   char szItems[1024];
  419.   DWORD dwIndex;
  420.   DWORD dwNumLogEntries;
  421.   DWORD dwReadLogIndex;
  422.   tagLogEntry *pLogEntry;
  423.   char szReturnValue[20];
  424.   char szOriginAddress[20];
  426.   Result = pGetLogParameters(&dwNumLogEntries, &dwReadLogIndex, &pLogEntry);
  428.   if (Result == false)
  429.     return false;
  431.   if (dwNumLogEntries)
  432.   {
  433.     WaitForSingleObject(hListViewMutex, INFINITE);
  435.     SendMessage(hWndListView, WM_SETREDRAW, FALSE, 0);
  436.   }
  437.   
  438.   for (dwIndex = 0; dwIndex < dwNumLogEntries; dwIndex++)
  439.   {
  441.     Result = GetProcessName9x(pLogEntry[dwReadLogIndex].dwProcessId, szItems);
  443.     if (Result == false)
  444.       strcpy(szItems, "?");
  446.     strcat(szItems, ";");
  447.     strcat(szItems, pLogEntry[dwReadLogIndex].szAPIName);
  449.     wsprintf(szReturnValue, "%#.8x", pLogEntry[dwReadLogIndex].dwReturnValue);
  450.     wsprintf(szOriginAddress, "%#.8x", pLogEntry[dwReadLogIndex].pvOriginAddress);
  452.     strcat(szItems, ";");
  453.     strcat(szItems, szReturnValue);
  454.     strcat(szItems, ";");
  455.     strcat(szItems, szOriginAddress);
  456.           
  457.     ListView_Append(szItems);
  459.     pAdvanceToNextLogEntry();
  460.   }
  462.   if (dwNumLogEntries)
  463.   {
  464.     SendMessage(hWndListView, WM_SETREDRAW, TRUE, 0);
  465.     InvalidateRect(hWndListView, NULL, FALSE);
  467.     ReleaseMutex(hListViewMutex);
  468.   }
  469.   
  470.   return true;
  471. }
  474. DWORD WINAPI LogThread9x(PVOID pvParameter)
  475. {
  476.   DWORD Result;
  477.   HANDLE hEventArray[2];
  479.   hEventArray[0] = hOverflowEvent;
  480.   hEventArray[1] = hLogThreadExitEvent;
  482.   while (1)
  483.   {
  484.     Result = WaitForMultipleObjects(2, &hEventArray[0], FALSE, 100);
  486.     switch (Result)
  487.     {
  488.       case WAIT_OBJECT_0:
  490.         // Buffer overflow
  492.         OutputLogBuffer();
  494.         ResetEvent(hOverflowEvent);
  495.         SetEvent(hLogEvent);
  497.       case WAIT_OBJECT_0 + 1:
  499.         // Exit event
  501.         ResetEvent(hLogThreadExitEvent);
  503.         return TRUE;
  505.       break;
  507.       case WAIT_TIMEOUT:
  509.         OutputLogBuffer();
  511.       break;
  513.       case WAIT_FAILED:
  515.         return FALSE;
  517.       break;
  518.     }
  519.   }
  521.   return TRUE;
  522. }
  525. DWORD WINAPI LogThreadNT(PVOID pvParameter)
  526. {
  527.   DWORD Result;
  528.   DWORD dwIndex;
  529.   DWORD dwBytesRead;
  530.   char szItems[1024];
  531.   char szReturnValue[20];
  532.   char szOriginAddress[20];
  533.   tagLogEntry LogEntry;
  534.   DWORD dwMessageSize;
  535.   DWORD dwMessageCount;
  537.   while (1)
  538.   {
  539.     Result = WaitForSingleObject(hLogThreadExitEvent, 100);
  541.     switch (Result)
  542.     {
  543.       case WAIT_OBJECT_0:
  545.         // Exit event
  547.         ResetEvent(hLogThreadExitEvent);
  548.       
  549.         return TRUE;
  551.       break;
  553.       case WAIT_TIMEOUT:
  555.         Result = GetMailslotInfo(hMailslot, 0, &dwMessageSize, &dwMessageCount, NULL);
  557.         if (Result && dwMessageCount)
  558.         {
  560.           WaitForSingleObject(hListViewMutex, INFINITE);
  562.           for (dwIndex = 0; dwIndex < dwMessageCount; dwIndex++)
  563.           {
  564.             Result = ReadFile(hMailslot, &LogEntry, sizeof(tagLogEntry), &dwBytesRead, NULL);
  566.             if (Result)
  567.             {
  568.               Result = GetProcessNameNT(LogEntry.dwProcessId, szItems);
  569.   
  570.               if (Result == false)
  571.                 strcpy(szItems, "?");
  573.               strcat(szItems, ";");
  574.               strcat(szItems, LogEntry.szAPIName);
  576.               wsprintf(szReturnValue, "%#.8x", LogEntry.dwReturnValue);
  577.               wsprintf(szOriginAddress, "%#.8x", LogEntry.pvOriginAddress);
  579.               strcat(szItems, ";");
  580.               strcat(szItems, szReturnValue);
  581.               strcat(szItems, ";");
  582.               strcat(szItems, szOriginAddress);
  583.           
  584.               ListView_Append(szItems);
  585.             }
  586.           }
  588.           ReleaseMutex(hListViewMutex);
  589.         }
  591.       break;
  593.       case WAIT_FAILED:
  595.         return FALSE;
  597.       break;
  598.     }
  599.   }
  601.   return TRUE;
  602. }
  605. DWORD WINAPI InjectDLLThread(PVOID pvParameter)
  606. {
  607.   DWORD Result;
  609.   while (1)
  610.   {
  611.     Result = WaitForSingleObject(hInjectThreadExitEvent, DLL_INJECTION_TIMEOUT);
  613.     switch (Result)
  614.     {
  615.       case WAIT_OBJECT_0:
  617.         ResetEvent(hInjectThreadExitEvent);
  619.         return TRUE;
  621.       break;
  623.       case WAIT_TIMEOUT:
  625.         InjectDLL(LOAD_DLL);
  627.       break;
  629.       case WAIT_FAILED:
  631.         return FALSE;
  633.       break;
  634.     }
  635.   }
  637.   return TRUE;
  638. }
  641. DWORD WINAPI ClearListViewThread(PVOID pvParameter)
  642. {
  643.   DWORD dwIndex;
  645.   WaitForSingleObject(hListViewMutex, INFINITE);
  647.   pSetCaptureEventsFlag(false);
  649.   if (IsNT == false)
  650.   {
  651.     SendMessage(hWndListView, WM_SETREDRAW, FALSE, 0);
  653.     DeletingListView = true;
  655.     for (dwIndex = 0; dwIndex < dwListViewRow; dwIndex++)
  656.       ListView_DeleteItem(hWndListView, 0);
  658.     DeletingListView = false;
  660.     SendMessage(hWndListView, WM_SETREDRAW, TRUE, 0);
  661.     InvalidateRect(hWndListView, NULL, FALSE);
  662.   }
  663.   else
  664.     ListView_DeleteAllItems(hWndListView);
  666.   dwListViewRow = 0;
  668.   pSetCaptureEventsFlag(CaptureEvents);
  670.   ReleaseMutex(hListViewMutex);
  672.   return TRUE;
  673. }
  676. void InitAPISpy32()
  677. {
  678.   SETAPISPY32PROCESSID_PROC pSetAPISpy32ProcessId;
  679.   HINSTANCE hInstDLL;
  680.   DWORD dwLogThreadId;
  681.   DWORD dwInjectDLLThreadId;
  682.   bool Result;
  684.   if (IsNT)
  685.   {
  686.     Result = ObtainSeDebugPrivilege();
  688.     if (Result == false)
  689.       ErrorHandler(WARNING_DEBUGPRIVILEGE, false);
  691.     hMailslot = CreateMailslot("\\.\mailslot\APISpy32_Mailslot", 0, MAILSLOT_WAIT_FOREVER, 0);
  693.     if (hMailslot == INVALID_HANDLE_VALUE)
  694.       ErrorHandler(ERROR_MAILSLOT, true);
  696.     hInstDLL = LoadLibrary(APISPY32DLL_NT);
  698.     if (hInstDLL == NULL)
  699.       ErrorHandler(ERROR_APISPY32DLL_NT, true);
  700.   }
  701.   else
  702.   {
  703.     hInstDLL = LoadLibrary(APISPY32DLL_9X);
  705.     if (hInstDLL == NULL)
  706.       ErrorHandler(ERROR_APISPY32DLL_9X, true);
  707.   }
  709.   if (IsNT)
  710.   {
  711.     Result = InitPSAPI();
  713.     if (Result == false)
  714.       ErrorHandler(ERROR_PSAPI, true);
  715.   }
  716.   else
  717.   {
  718.     Result = InitToolhelp32();
  720.     if (Result == false)
  721.       ErrorHandler(ERROR_TOOLHELP32, true);
  722.   }
  724.   hLogMutex = CreateMutex(NULL, FALSE, "APISpy32_LogMutex");
  726.   if (hLogMutex == NULL)
  727.     ErrorHandler(ERROR_LOGMUTEX, true);
  729.   hOverflowEvent = CreateEvent(NULL, TRUE, FALSE, "APISpy32_OverflowEvent");
  731.   if (hOverflowEvent == NULL)
  732.     ErrorHandler(ERROR_OVERFLOWEVENT, true);
  734.   hLogEvent = CreateEvent(NULL, TRUE, FALSE, "APISpy32_LogEvent");
  736.   if (hLogEvent == NULL)
  737.     ErrorHandler(ERROR_LOGEVENT, true);
  739.   hLogThreadExitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  741.   if (hLogThreadExitEvent == NULL)
  742.     ErrorHandler(ERROR_LOGTHREADEXITEVENT, true);
  744.   hInjectThreadExitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  746.   if (hInjectThreadExitEvent == NULL)
  747.     ErrorHandler(ERROR_INJECTTHREADEXITEVENT, true);
  749.   hListViewMutex = CreateMutex(NULL, FALSE, NULL);
  751.   if (hListViewMutex == NULL)
  752.     ErrorHandler(ERROR_LISTVIEWMUTEX, true);
  754.   if (!IsNT)
  755.   {
  756.     pGetLogParameters = (GETLOGPARAMETERS_PROC)GetProcAddress(hInstDLL, "GetLogParameters");
  758.     if (pGetLogParameters == NULL)
  759.       ErrorHandler(ERROR_GETLOGPARAMETERS, true);
  761.     pAdvanceToNextLogEntry = (ADVANCETONEXTLOGENTRY_PROC)GetProcAddress(hInstDLL, "AdvanceToNextLogEntry");
  763.     if (pAdvanceToNextLogEntry == NULL)
  764.       ErrorHandler(ERROR_ADVANCETONEXTLOGENTRY, true);
  765.   }
  767.   pSetCaptureEventsFlag = (SETCAPTUREEVENTSFLAG_PROC)GetProcAddress(hInstDLL, "SetCaptureEventsFlag");
  769.   if (pSetCaptureEventsFlag == NULL)
  770.     ErrorHandler(ERROR_SETCAPTUREEVENTSFLAG, true);
  772.   pSetAPISpy32ProcessId = (SETAPISPY32PROCESSID_PROC)GetProcAddress(hInstDLL, "SetAPISpy32ProcessId");
  774.   if (pSetAPISpy32ProcessId == NULL)
  775.     ErrorHandler(ERROR_SETAPISPY32PROCESSID, true);
  777.   pSetAPISpy32ProcessId(GetCurrentProcessId());
  779.   if (IsNT)
  780.   {
  781.     hInjectDLLThread = CreateThread(NULL, 0, InjectDLLThread, 0, 0, &dwInjectDLLThreadId);
  783.     if (hInjectDLLThread == NULL)
  784.       ErrorHandler(ERROR_INJECTDLLTHREAD, true);
  786.     hLogThread = CreateThread(NULL, 0, LogThreadNT, 0, 0, &dwLogThreadId);
  787.   }
  788.   else
  789.     hLogThread = CreateThread(NULL, 0, LogThread9x, 0, 0, &dwLogThreadId);
  791.   if (hLogThread == NULL)
  792.     ErrorHandler(ERROR_LOGTHREAD, true);
  794.   // Start capturing events
  796.   pSetCaptureEventsFlag(true);
  797. }
  800. bool ShutdownAPISpy32()
  801. {
  802.   if (pSetCaptureEventsFlag)
  803.     pSetCaptureEventsFlag(false);
  805.   if (dwHelpCookie)
  806.   {
  807.     HtmlHelp(NULL, NULL, HH_CLOSE_ALL, 0);
  808.     HtmlHelp(NULL, NULL, HH_UNINITIALIZE, dwHelpCookie);
  809.   }
  811.   if (IsNT)
  812.   {
  813.     // Wait until the injection thread resumes
  815.     SetEvent(hInjectThreadExitEvent);
  816.     WaitForSingleObject(hInjectDLLThread, THREAD_EXIT_TIMEOUT);
  817.   }
  819.   // Wait until the logging thread resumes
  821.   SetEvent(hLogThreadExitEvent);
  822.   WaitForSingleObject(hLogThread, THREAD_EXIT_TIMEOUT);
  824.   // Remove the interception DLL from all address spaces
  826.   if (IsNT)
  827.     InjectDLL(FREE_DLL);
  829.   // Close handles of event objects
  831.   if (hOverflowEvent)
  832.     CloseHandle(hOverflowEvent);
  834.   if (hLogEvent)
  835.     CloseHandle(hLogEvent);
  837.   if (hInjectThreadExitEvent)
  838.     CloseHandle(hInjectThreadExitEvent);
  840.   if (hLogThreadExitEvent)
  841.     CloseHandle(hLogThreadExitEvent);
  843.   // Close handles of mutex objects
  845.   if (hListViewMutex)
  846.     CloseHandle(hListViewMutex);
  848.   if (hLogMutex)
  849.     CloseHandle(hLogMutex);
  850.   
  851.   // Close handles of threads
  853.   if (hLogThread)
  854.     CloseHandle(hLogThread);
  856.   if (hInjectDLLThread)
  857.     CloseHandle(hInjectDLLThread);
  859.   // Close handle of mailslot
  861.   if (IsNT && hMailslot)
  862.     CloseHandle(hMailslot);
  864.   return true;
  865. }
  868. DWORD WINAPI SaveLogFileThread(PVOID SaveAs)
  869. {
  870.   OPENFILENAME OpenFileName;
  871.   BOOL Result;
  872.   DWORD dwRow;
  873.   DWORD dwColumn;
  874.   FILE *hLogFile;
  875.   char szItemText[256] = "";
  876.   char szListViewText[1024];
  877.   static bool LogFileChosen = false;
  878.   static char szLogFileName[MAX_PATH];
  880.   if (SaveAs || !LogFileChosen)
  881.   {
  882.     OpenFileName.lStructSize       =  sizeof(OPENFILENAME);
  883.     OpenFileName.hwndOwner         =  hWndMain;
  884.     OpenFileName.hInstance         =  (HINSTANCE)hInst;
  885.     OpenFileName.lpstrFilter       =  "Log Files (*.log)*.logAll Files (*.*)*.*";
  886.     OpenFileName.lpstrCustomFilter =  (LPTSTR)NULL;
  887.     OpenFileName.nMaxCustFilter    =  0L;
  888.     OpenFileName.nFilterIndex      =  1L;
  889.     OpenFileName.lpstrFile         =  szLogFileName;
  890.     OpenFileName.nMaxFile          =  256;
  891.     OpenFileName.lpstrFileTitle    =  NULL;
  892.     OpenFileName.nMaxFileTitle     =  0;
  893.     OpenFileName.lpstrInitialDir   =  NULL;
  894.     OpenFileName.lpstrTitle        =  "Save File Info...";
  895.     OpenFileName.nFileOffset       =  0;
  896.     OpenFileName.nFileExtension    =  0;
  897.     OpenFileName.lpstrDefExt       =  "*.log";
  898.     OpenFileName.lpfnHook          =  NULL;
  899.     OpenFileName.Flags             =  OFN_LONGNAMES | OFN_HIDEREADONLY;
  901.     Result = GetSaveFileName(&OpenFileName);
  903.     if (Result == FALSE)
  904.       return FALSE;
  905.   }
  907.   hLogFile = fopen(szLogFileName, "w");
  909.   if (hLogFile == NULL)
  910.   {
  911.     ErrorHandler(WARNING_OPENLOGFILE, false);
  912.     return FALSE;
  913.   }
  915.   WaitForSingleObject(hListViewMutex, INFINITE);
  917.   for (dwRow = 0; dwRow < dwListViewRow; dwRow++)
  918.   {
  919.     strcpy(szListViewText, "");
  921.     for (dwColumn = 0; dwColumn < NUMCOLUMNS; dwColumn++)
  922.     {
  923.       ListView_GetItemText(hWndListView, dwRow, dwColumn, szItemText, sizeof(szItemText)); 
  925.       strcat(szListViewText, szItemText);
  926.       strcat(szListViewText, "t");
  927.     }
  929.     fprintf(hLogFile, "%sn", szListViewText);
  930.   }
  932.   fclose(hLogFile);
  934.   ReleaseMutex(hListViewMutex);
  936.   LogFileChosen = true;
  938.   return TRUE;
  939. }
  942. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  943. {
  944.   LPTOOLTIPTEXT pToolTipText;
  945.   char szToolTipText[128];
  946.   PAINTSTRUCT PaintStruct;
  947.   DWORD dwClearListViewThreadId;
  948.   HANDLE hClearListViewThread;
  949.   DWORD dwSaveLogFileThreadId;
  950.   HANDLE hSaveLogFileThread;
  951.   DWORD DllVersion;
  952.   DWORD Result;
  953.   HDC hDC;
  955.   switch (uMsg)
  956.   {
  957.     case WM_CREATE:
  959.       DllVersion = GetDLLVersion("comctl32.dll");
  961.       if (DllVersion >= PACKVERSION(4, 71))
  962.         hWndToolbar = CreateToolbarEx(hWnd, TOOLBAR_FLAT | WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS, ID_TOOLBAR, 10, hInst, IDB_TOOLBAR, (LPCTBBUTTON)&tbButtons, NUM_TOOLBAR_BUTTONS, 16, 16, 16, 15, sizeof(TBBUTTON));
  963.       else
  964.         hWndToolbar = CreateToolbarEx(hWnd, WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS, ID_TOOLBAR, 10, hInst, IDB_TOOLBAR, (LPCTBBUTTON)&tbButtonsOld, NUM_OLD_TOOLBAR_BUTTONS, 16, 16, 16, 15, sizeof(TBBUTTON));
  965.       
  966.       if (hWndToolbar == NULL)
  967.         ErrorHandler(WARNING_TOOLBAR, false);
  969.       hWndListView = CreateListView(hWnd);
  971.       if (hWndListView == NULL)
  972.         ErrorHandler(ERROR_LISTVIEW, true);
  974.       HtmlHelp(NULL, NULL, HH_INITIALIZE, (DWORD)&dwHelpCookie);
  975.  
  976.       // Initialize the API interception engine
  978.       InitAPISpy32();
  980.     break;
  982.     case WM_NOTIFY:
  984.       if (((LPNMHDR)lParam)->code == TTN_NEEDTEXT)
  985.       {
  986.         pToolTipText = (LPTOOLTIPTEXT)lParam;
  987.         LoadString(hInst, pToolTipText->hdr.idFrom, szToolTipText, sizeof(szToolTipText));
  988.         pToolTipText->lpszText = szToolTipText;
  989.       }
  990.       
  991.     break;
  993.     case WM_SIZE:
  995.       MoveWindow(hWndToolbar, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
  996.       MoveWindow(hWndListView, 0, TOOLBARHEIGHT, LOWORD(lParam), HIWORD(lParam) - TOOLBARHEIGHT, TRUE);
  998.     break;
  1000.     case WM_CLOSE:
  1002.       ShutdownAPISpy32();
  1004.       WriteSettings(hWnd);
  1006.       return DefWindowProc(hWnd, uMsg, wParam, lParam);
  1008.     break;
  1010.     case WM_SETFOCUS:
  1012.       SetFocus(hWndListView);
  1014.     break;
  1016.     case WM_PAINT:
  1018.       if (IsNT == false && DeletingListView)
  1019.       {
  1020.         hDC = BeginPaint(hWnd, &PaintStruct);
  1021.         EndPaint(hWnd, &PaintStruct);
  1023.         return TRUE;
  1024.       }
  1026.       return DefWindowProc(hWnd, uMsg, wParam, lParam);
  1027.     
  1028.     break;
  1030.     case WM_DESTROY:
  1032.       PostQuitMessage(0);
  1034.     break;
  1036.     case WM_COMMAND:
  1038.       switch (LOWORD(wParam))
  1039.       {
  1040.         case IDM_CLEAR:
  1042.           hClearListViewThread = CreateThread(NULL, 0, ClearListViewThread, NULL, 0, &dwClearListViewThreadId);
  1043.           
  1044.           if (hClearListViewThread)
  1045.             CloseHandle(hClearListViewThread);
  1047.         break;
  1049.         case IDM_HELP:
  1051.           if (dwHelpCookie)
  1052.             HtmlHelp(hWnd, "APISpy32.chm", HH_DISPLAY_TOPIC, NULL);
  1053.           else
  1054.           {
  1055.             Result = (DWORD)ShellExecute(hWnd, "open", "APISpy32.htm", NULL, NULL, SW_SHOWNORMAL);
  1057.             if (Result <= 32)
  1058.               ErrorHandler(WARNING_SHELLEXECUTE, false);
  1059.           }
  1061.         break;
  1063.         case IDM_AUTOSCROLL:
  1065.           AutoScroll = !AutoScroll;
  1066.           CheckMenuItem(GetMenu(hWnd), IDM_AUTOSCROLL, MF_BYCOMMAND | (AutoScroll ? MF_CHECKED:MF_UNCHECKED));
  1067.           SendMessage(hWndToolbar, TB_CHANGEBITMAP, IDM_AUTOSCROLL, (AutoScroll ? 4:3));
  1068.           InvalidateRect(hWndToolbar, NULL, TRUE);
  1069.           
  1070.         break;
  1072.         case IDM_ONTOP:
  1074.           WindowOnTop = !WindowOnTop;
  1076.           if (WindowOnTop)
  1077.             SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
  1078.           else
  1079.             SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
  1081.           CheckMenuItem(GetMenu(hWnd), IDM_ONTOP, MF_BYCOMMAND | (WindowOnTop ? MF_CHECKED:MF_UNCHECKED));
  1083.         break;
  1085.         case IDM_CAPTURE:
  1087.           CaptureEvents = !CaptureEvents;
  1088.           CheckMenuItem(GetMenu(hWnd), IDM_CAPTURE, MF_BYCOMMAND | (CaptureEvents ? MF_CHECKED:MF_UNCHECKED));
  1089.           SendMessage(hWndToolbar, TB_CHANGEBITMAP, IDM_CAPTURE, (CaptureEvents ? 2:1));
  1090.           InvalidateRect(hWndToolbar, NULL, TRUE);
  1092.           // Notify the DLL about the change
  1094.           pSetCaptureEventsFlag(CaptureEvents);
  1096.         break;
  1098.         case IDM_SAVE:
  1100.           hSaveLogFileThread = CreateThread(NULL, 0, SaveLogFileThread, FALSE, 0, &dwSaveLogFileThreadId);
  1102.           if (hSaveLogFileThread)
  1103.             CloseHandle(hSaveLogFileThread);
  1104.           
  1105.         break;
  1107.         case IDM_SAVEAS:
  1109.           hSaveLogFileThread = CreateThread(NULL, 0, SaveLogFileThread, (PVOID)TRUE, 0, &dwSaveLogFileThreadId);
  1111.           if (hSaveLogFileThread)
  1112.             CloseHandle(hSaveLogFileThread);
  1114.         break;
  1116.         case IDM_ABOUT:
  1118.           DialogBox(hInst, "AboutBox", hWnd, (DLGPROC)AboutBoxWndProc);
  1120.         break;
  1122.         case IDM_EXIT:
  1124.           SendMessage(hWnd, WM_CLOSE, 0, 0);
  1126.         break;
  1128.         default:
  1130.           return DefWindowProc(hWnd, uMsg, wParam, lParam);
  1132.         break;
  1133.       }
  1135.     break;
  1137.     default:
  1139.       return DefWindowProc(hWnd, uMsg, wParam, lParam);
  1140.   }
  1142.   return FALSE;
  1143. }
  1146. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
  1147. {
  1148.   bool Result;
  1149.   HWND hWnd;
  1150.   HWND hWndPrevInst;
  1151.   HACCEL hAccel;
  1152.   MSG msg;
  1154.   // Is this a second instance ?
  1156.   hWndPrevInst = FindWindow("APISpy32Class", "APISpy32 - http://www.internals.com");
  1158.   // If so, activate the previous one and terminate
  1160.   if (hWndPrevInst)
  1161.   {
  1162.     OpenIcon(hWndPrevInst);
  1163.     SetForegroundWindow(hWndPrevInst);
  1164.     return 0;
  1165.   }
  1167.   Result = GetWindowsVersion();
  1169.   if (Result == false)
  1170.     ErrorHandler(ERROR_GETWINDOWSVERSION, true);
  1172.   InitApplication(hInstance);
  1174.   hWnd = InitInstance(hInstance, nCmdShow); 
  1176.   if (hWnd == NULL)
  1177.     ErrorHandler(ERROR_INITINSTANCE, true);
  1179.   hAccel = LoadAccelerators(hInstance, "ACCELERATORS");
  1181.   if (hAccel == NULL)
  1182.     ErrorHandler(WARNING_ACCELERATORS, false);
  1184.   while (GetMessage(&msg, NULL, 0, 0))
  1185.   {
  1186.     if (!TranslateAccelerator(hWnd, hAccel, &msg))
  1187.     {
  1188.       TranslateMessage(&msg);
  1189.       DispatchMessage(&msg);
  1190.     }
  1191.   }
  1193.   return msg.wParam;
  1194. }