home *** CD-ROM | disk | FTP | other *** search
/ PC World 2004 November / PCWorld_2004-11_cd.bin / software / temacd / poweroff / pwroff30.exe / src / processbrowser.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-10-16  |  18.6 KB  |  674 lines
  1. #include "poweroff.h"
  2.  
  3. #include <tlhelp32.h>
  4. #include <vdmdbg.h>
  5.  
  6. typedef struct
  7. {
  8.   DWORD          dwPID ;
  9.   PROCENUMPROC   lpProc ;
  10.   DWORD          lParam ;
  11.   BOOL           bEnd ;
  12. } EnumInfoStruct ;
  13.  
  14. typedef PERF_DATA_BLOCK             PERF_DATA,      *PPERF_DATA;
  15. typedef PERF_OBJECT_TYPE            PERF_OBJECT,    *PPERF_OBJECT;
  16. typedef PERF_INSTANCE_DEFINITION    PERF_INSTANCE,  *PPERF_INSTANCE;
  17. typedef PERF_COUNTER_DEFINITION     PERF_COUNTER,   *PPERF_COUNTER;
  18.  
  19.  
  20. // ToolHelp Function Pointers.
  21. HINSTANCE      hInstLib=NULL;
  22. HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
  23. BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
  24. BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
  25. BOOL (WINAPI *lpfModule32First)(HANDLE,LPMODULEENTRY32) ;
  26. BOOL (WINAPI *lpfModule32Next)(HANDLE,LPMODULEENTRY32) ;
  27.  
  28. BOOL WINAPI Enum16( DWORD dwThreadId, WORD hMod16, WORD hTask16,
  29.   PSZ pszModName, PSZ pszFileName, LPARAM lpUserDefined ) ;
  30.  
  31. BOOL GetProcessModule (DWORD dwPID, DWORD dwModuleID, 
  32.      LPMODULEENTRY32 lpMe32, DWORD cbMe32) 
  33. { 
  34.     BOOL          bRet        = FALSE; 
  35.     BOOL          bFound      = FALSE; 
  36.     HANDLE        hModuleSnap = NULL; 
  37.     MODULEENTRY32 me32        = {0}; 
  38.  
  39.     // Take a snapshot of all modules in the specified process. 
  40.  
  41.     Log("GetProcessModule start");
  42.     hModuleSnap = lpfCreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwPID); 
  43.     if (hModuleSnap == (HANDLE)-1) 
  44.     {
  45.       Log("CreateToolhelp32Snapshot failed");
  46.       Log("GetProcessModule end");
  47.       return (FALSE); 
  48.     }
  49.  
  50.     // Fill the size of the structure before using it. 
  51.  
  52.     me32.dwSize = sizeof(MODULEENTRY32); 
  53.  
  54.     // Walk the module list of the process, and find the module of 
  55.     // interest. Then copy the information to the buffer pointed 
  56.     // to by lpMe32 so that it can be returned to the caller. 
  57.  
  58.     if (lpfModule32First(hModuleSnap, &me32)) 
  59.     { 
  60.         do 
  61.         { 
  62.             if (me32.th32ModuleID == dwModuleID) 
  63.             { 
  64.                 CopyMemory (lpMe32, &me32, cbMe32); 
  65.                 bFound = TRUE; 
  66.             } 
  67.         } 
  68.         while (!bFound && lpfModule32Next(hModuleSnap, &me32)); 
  69.  
  70.         bRet = bFound;   // if this sets bRet to FALSE, dwModuleID 
  71.                          // no longer exists in specified process 
  72.     } 
  73.     else 
  74.         bRet = FALSE;           // could not walk module list 
  75.  
  76.     // Do not forget to clean up the snapshot object. 
  77.  
  78.     CloseHandle (hModuleSnap); 
  79.  
  80.     Log("GetProcessModule end (bret=%d)",(int)bRet);
  81.     return (bRet); 
  82. } 
  83.  
  84. PPERF_OBJECT FirstObject (PPERF_DATA pData)
  85. {
  86.   Log("FirstObject, pData=%p",pData);
  87.   if (pData)
  88.     return ((PPERF_OBJECT) ((PBYTE) pData + pData->HeaderLength));
  89.   else
  90.     return NULL;
  91. }
  92.  
  93. PPERF_OBJECT NextObject (PPERF_OBJECT pObject)
  94. {
  95.   Log("NextObject, pData=%p",pObject);
  96.   if (pObject)
  97.     return ((PPERF_OBJECT) ((PBYTE) pObject + pObject->TotalByteLength));
  98.   else
  99.     return NULL;
  100. }
  101.  
  102. PPERF_OBJECT FindObject (PPERF_DATA pData, DWORD TitleIndex)
  103. {
  104.   PPERF_OBJECT pObject;
  105.   DWORD        i = 0;
  106.  
  107.   Log("FindObject start");
  108.   if (pObject = FirstObject(pData))
  109.   {
  110.     Log("pData->NumObjectTypes=%d",(int)pData->NumObjectTypes);
  111.     while (i < pData->NumObjectTypes)
  112.     {
  113.       Log("pObject->ObjectNameTitleIndex=%d, TitleIndex=%d",(int)pObject->ObjectNameTitleIndex,(int)TitleIndex);
  114.       if (pObject->ObjectNameTitleIndex == TitleIndex)
  115.       {
  116.         Log("FindObject end, pObject=%p",pObject);
  117.         return pObject;
  118.       }
  119.       pObject = NextObject(pObject);
  120.       i++;
  121.     }
  122.   }
  123.   Log("FindObject end");
  124.   return NULL;
  125. }
  126.  
  127. DWORD GetPerfData(HKEY        hPerfKey,
  128.                   LPTSTR      szObjectIndex,
  129.                   PPERF_DATA  *ppData,
  130.                   DWORD       *pDataSize)
  131. {
  132.   DWORD   DataSize;
  133.   DWORD   dwR;
  134.   DWORD   Type;
  135.  
  136.   Log("GetPerfData start (szObjectIndex=%s,pDataSize=%d)",szObjectIndex,(int)*pDataSize);
  137.   if (!*ppData)
  138.     *ppData = (PPERF_DATA) LocalAlloc (LMEM_FIXED, *pDataSize);
  139.   Log("ppData=%p",*ppData);
  140.  
  141.   do  
  142.   {
  143.     DataSize = *pDataSize;
  144.     dwR = RegQueryValueEx (hPerfKey,
  145.                            szObjectIndex,
  146.                            NULL,
  147.                            &Type,
  148.                            (BYTE *)*ppData,
  149.                            &DataSize);
  150.  
  151.     Log("dwR=%d",(int)dwR);
  152.     if (dwR == ERROR_MORE_DATA)
  153.     {
  154.       LocalFree (*ppData);
  155.       *pDataSize += 1024;
  156.       *ppData = (PPERF_DATA) LocalAlloc (LMEM_FIXED, *pDataSize);
  157.       Log("ppData=%p, size=%d",*ppData,(int)*pDataSize);
  158.     }
  159.  
  160.     if (!*ppData)
  161.     {
  162.       LocalFree (*ppData);
  163.       Log("GetPerfData end (ERROR_NOT_ENOUGH_MEMORY)");
  164.       return ERROR_NOT_ENOUGH_MEMORY;
  165.     }
  166.  
  167.   } while (dwR == ERROR_MORE_DATA);
  168.  
  169.   Log("GetPerfData end (dwR=%d)",(int)dwR);
  170.   return dwR;
  171. }
  172.  
  173.  
  174. PPERF_DATA RefreshPerfData (HKEY        hPerfKey,
  175.                             LPTSTR      szObjectIndex,
  176.                             PPERF_DATA  pData,
  177.                             DWORD       *pDataSize)
  178. {
  179.   Log("RefreshPerfData");
  180.   if (GetPerfData (hPerfKey, szObjectIndex, &pData, pDataSize) == ERROR_SUCCESS)
  181.     return pData;
  182.   else
  183.     return NULL;
  184. }
  185.  
  186. DWORD   GetPerfTitleSz (HKEY    hKeyMachine,
  187.                         HKEY    hKeyPerf,
  188.                         LPTSTR  *TitleBuffer,
  189.                         LPTSTR  *TitleSz[],
  190.                         DWORD   *TitleLastIdx)
  191. {
  192.   HKEY      hKey1;
  193.   HKEY    hKey2;
  194.   DWORD   Type;
  195.   DWORD   DataSize;
  196.   DWORD   dwR;
  197.   DWORD   Len;
  198.   DWORD   Index;
  199.   DWORD   dwTemp;
  200.   BOOL    bNT10;
  201.   LPTSTR  szCounterValueName;
  202.   LPTSTR  szTitle;
  203.  
  204.   Log("GetPerfTitleSz start");
  205.   // Initialize
  206.   //
  207.   hKey1        = NULL;
  208.   hKey2        = NULL;
  209.   *TitleBuffer = NULL;
  210.   *TitleSz     = NULL;
  211.  
  212.   // Open the perflib key to find out the last counter's index and system version.
  213.   //
  214.   dwR = RegOpenKeyEx (hKeyMachine,
  215.                       TEXT("software\\microsoft\\windows nt\\currentversion\\perflib"),
  216.                       0,
  217.                       KEY_READ,
  218.                       &hKey1);
  219.   Log("RegOpenKeyEx: dwR=%d",(int)dwR);
  220.   if (dwR != ERROR_SUCCESS)
  221.       goto done;
  222.  
  223.   // Get the last counter's index so we know how much memory to allocate for TitleSz
  224.   //
  225.   DataSize = sizeof (DWORD);
  226.   dwR = RegQueryValueEx (hKey1, TEXT("Last Counter"), 0, &Type, (LPBYTE)TitleLastIdx, &DataSize);
  227.   Log("RegQueryValueEx(Last Counter): dwR=%d, TitleLastIdx=%d",(int)dwR,(int)*TitleLastIdx);
  228.   if (dwR != ERROR_SUCCESS)
  229.     goto done;
  230.  
  231.  
  232.  
  233.   // Find system version, for system earlier than 1.0a, there's no version value.
  234.   //
  235.   dwR = RegQueryValueEx (hKey1, TEXT("Version"), 0, &Type, (LPBYTE)&dwTemp, &DataSize);
  236.   Log("RegQueryValueEx(Version): dwR=%d, dwTemp=%d",(int)dwR,(int)dwTemp);
  237.  
  238.   if (dwR != ERROR_SUCCESS)
  239.     // unable to read the value, assume NT 1.0
  240.     bNT10 = TRUE;
  241.   else
  242.     // found the value, so, NT 1.0a or later
  243.     bNT10 = FALSE;
  244.  
  245.   // Now, get ready for the counter names and indexes.
  246.   //
  247.   if (bNT10)
  248.   {
  249.     // NT 1.0, so make hKey2 point to ...\perflib\009 and get
  250.     //  the counters from value "Counters"
  251.     //
  252.     szCounterValueName = TEXT("Counters");
  253.     dwR = RegOpenKeyEx (hKeyMachine,
  254.                         TEXT("software\\microsoft\\windows nt\\currentversion\\perflib\\009"),
  255.                         0,
  256.                         KEY_READ,
  257.                         &hKey2);
  258.     Log("RegOpenKeyEx: dwR=%d",(int)dwR);
  259.     if (dwR != ERROR_SUCCESS)
  260.         goto done;
  261.   }
  262.   else
  263.   {
  264.     // NT 1.0a or later.  Get the counters in key HKEY_PERFORMANCE_KEY
  265.     //  and from value "Counter 009"
  266.     //
  267.     szCounterValueName = TEXT("Counter 009");
  268.     hKey2 = hKeyPerf;
  269.   }
  270.  
  271.   // Find out the size of the data.
  272.   //
  273.   dwR = RegQueryValueEx (hKey2, szCounterValueName, 0, &Type, 0, &DataSize);
  274.   Log("RegQueryValueEx(%s): dwR=%d, Type=%d",szCounterValueName,(int)dwR,(int)Type);
  275.   if (dwR != ERROR_SUCCESS)
  276.     goto done;
  277.  
  278.   // Allocate memory
  279.   //
  280.   *TitleBuffer = (LPTSTR)LocalAlloc (LMEM_FIXED, DataSize);
  281.   if (!*TitleBuffer)
  282.   {
  283.     dwR = ERROR_NOT_ENOUGH_MEMORY;
  284.     Log("ERROR_NOT_ENOUGH_MEMORY");
  285.     goto done;
  286.   }
  287.   Log("TitleBuffer=%p",TitleBuffer);
  288.  
  289.   *TitleSz = (LPTSTR *)LocalAlloc (LPTR, (*TitleLastIdx+1) * sizeof (LPTSTR));
  290.   if (!*TitleSz)
  291.   {
  292.     dwR = ERROR_NOT_ENOUGH_MEMORY;
  293.     Log("ERROR_NOT_ENOUGH_MEMORY");
  294.     goto done;
  295.   }
  296.   Log("TitleSz=%p",TitleSz);
  297.  
  298.   // Query the data
  299.   //
  300.   dwR = RegQueryValueEx (hKey2, szCounterValueName, 0, &Type, (BYTE *)*TitleBuffer, &DataSize);
  301.   Log("RegQueryValueEx(%s): dwR=%d, TitleBuffer=%s",szCounterValueName,(int)dwR,*TitleBuffer);
  302.   if (dwR != ERROR_SUCCESS)
  303.     goto done;
  304.  
  305.   // Setup the TitleSz array of pointers to point to beginning of each title string.
  306.   // TitleBuffer is type REG_MULTI_SZ.
  307.   //
  308.   szTitle = *TitleBuffer;
  309.  
  310.   while (Len = lstrlen (szTitle))
  311.   {
  312.     Index = atoi (szTitle);
  313.     Log("Index=%d",(int)Index);
  314.     szTitle = szTitle + Len +1;
  315.  
  316.     Log("Index=%d, *TitleLastIdx=%d",(int)Index,(int)*TitleLastIdx);
  317.     if (Index <= *TitleLastIdx)
  318.     {
  319.       Log("Title=%s",szTitle);
  320.       (*TitleSz)[Index] = szTitle;
  321.     }
  322.     szTitle = szTitle + lstrlen (szTitle) +1;
  323.   }
  324.  
  325. done:
  326.  
  327.   Log("Done");
  328.   // Done. Now cleanup!
  329.   //
  330.   if (dwR != ERROR_SUCCESS)
  331.   {
  332.     // There was an error, free the allocated memory
  333.     //
  334.     if (*TitleBuffer) LocalFree (*TitleBuffer);
  335.     if (*TitleSz)     LocalFree (*TitleSz);
  336.   }
  337.  
  338.   // Close the hKeys.
  339.   //
  340.   if (hKey1) 
  341.     RegCloseKey (hKey1);
  342.   if (hKey2 && hKey2 != hKeyPerf) 
  343.     RegCloseKey (hKey2);
  344.  
  345.   Log("GetPerfTitleSz end");
  346.   return dwR;
  347. }
  348.  
  349.  
  350. DWORD GetTitleIdx(char *name)
  351. {
  352.   DWORD   Index;
  353.   LPTSTR  TitleBuffer;
  354.   LPTSTR  *Title;
  355.   DWORD   Last;
  356.   DWORD   dwR;
  357.  
  358.   Log("GetTitleIdx start");
  359.   dwR = GetPerfTitleSz (HKEY_LOCAL_MACHINE, HKEY_PERFORMANCE_DATA, &TitleBuffer, &Title, &Last);
  360.  
  361.   Log("dwR=%d",(int)dwR);
  362.   if (dwR != ERROR_SUCCESS)
  363.   {
  364.     Log("GetTitleIdx start");
  365.     return 0;
  366.   }
  367.  
  368.   for (Index = 0; Index <= Last; Index++)
  369.   {
  370.     if (Title[Index])
  371.     {
  372.       Log("Title[%d]=%s, name=%s",Index,Title[Index], name);
  373.       if (!lstrcmpi (Title[Index], name))
  374.       {
  375.         LocalFree (TitleBuffer);
  376.         LocalFree (Title);
  377.         Log("GetTitleIdx end (Index=%d)",(int)Index);
  378.         return Index;
  379.       }
  380.     }
  381.   }
  382.  
  383.   LocalFree (TitleBuffer);
  384.   LocalFree (Title);
  385.   Log("GetTitleIdx end");
  386.   return 0;
  387. }
  388.  
  389. PPERF_COUNTER FirstCounter (PPERF_OBJECT pObject)
  390. {
  391.   Log("FirstCounter, pObject=%p",pObject);
  392.   if (pObject)
  393.     return (PPERF_COUNTER)((PCHAR) pObject + pObject->HeaderLength);
  394.   else
  395.     return NULL;
  396. }
  397.  
  398. PPERF_COUNTER NextCounter (PPERF_COUNTER pCounter)
  399. {
  400.   Log("NextCounter, pCounter=%p",pCounter);
  401.   if (pCounter)
  402.     return (PPERF_COUNTER)((PCHAR) pCounter + pCounter->ByteLength);
  403.   else
  404.     return NULL;
  405. }
  406.  
  407. PPERF_COUNTER FindCounter (PPERF_OBJECT pObject, DWORD TitleIndex)
  408. {
  409.   PPERF_COUNTER pCounter;
  410.   DWORD         i = 0;
  411.  
  412.   Log("FindCounter start, pObject=%p, TitleIndex=%d",pObject,(int)TitleIndex);
  413.   if (pCounter = FirstCounter (pObject))
  414.   {
  415.     Log("pObject->NumCounters=%d",(int)pObject->NumCounters);
  416.     while (i < pObject->NumCounters)
  417.     {
  418.       Log("pCounter->CounterNameTitleIndex=%d",(int)pCounter->CounterNameTitleIndex);
  419.       if (pCounter->CounterNameTitleIndex == TitleIndex)
  420.       {
  421.         Log("FindCounter end (pCounter=%p)",pCounter);
  422.         return pCounter;
  423.       }
  424.  
  425.       pCounter = NextCounter (pCounter);
  426.       i++;
  427.     }
  428.   }
  429.  
  430.   Log("FindCounter end");
  431.   return NULL;
  432. }
  433.  
  434. PPERF_INSTANCE FirstInstance (PPERF_OBJECT pObject)
  435. {
  436.   Log("FirstInstance (pObject=%p)",pObject);
  437.   if (pObject)
  438.     return (PPERF_INSTANCE)((PCHAR) pObject + pObject->DefinitionLength);
  439.   else
  440.     return NULL;
  441. }
  442.  
  443. PPERF_INSTANCE NextInstance (PPERF_INSTANCE pInst)
  444. {
  445.   PERF_COUNTER_BLOCK *pCounterBlock;
  446.  
  447.   Log("NextInstance (pInst=%p)",pInst);
  448.   if (pInst)
  449.   {
  450.     pCounterBlock = (PERF_COUNTER_BLOCK *)((PCHAR) pInst + pInst->ByteLength);
  451.     return (PPERF_INSTANCE)((PCHAR) pCounterBlock + pCounterBlock->ByteLength);
  452.   }
  453.   else
  454.     return NULL;
  455. }
  456.  
  457. PVOID CounterData (PPERF_INSTANCE pInst, PPERF_COUNTER pCount)
  458. {
  459.   PPERF_COUNTER_BLOCK pCounterBlock;
  460.  
  461.   Log("CounterData (pInst=%p, pCount=%p)",pInst,pCount);
  462.   if (pCount && pInst)
  463.   {
  464.     pCounterBlock = (PPERF_COUNTER_BLOCK)((PCHAR)pInst + pInst->ByteLength);
  465.     return (PVOID)((PCHAR)pCounterBlock + pCount->CounterOffset);
  466.   }
  467.   else
  468.     return NULL;
  469. }
  470.  
  471. LPTSTR  InstanceName (PPERF_INSTANCE pInst)
  472. {
  473.   Log("InstanceName (pInst=%p)",pInst);
  474.   if (pInst)
  475.     return (LPTSTR) ((PCHAR) pInst + pInst->NameOffset);
  476.   else
  477.     return NULL;
  478. }
  479.  
  480. // The EnumProcs function takes a pointer to a callback function
  481. // that will be called once per process in the system providing
  482. // process EXE filename and process ID.
  483. // Callback function definition:
  484. // BOOL CALLBACK Proc( DWORD dw, LPCSTR lpstr, LPARAM lParam ) ;
  485. // 
  486. // lpProc -- Address of callback routine.
  487. // 
  488. // lParam -- A user-defined LPARAM value to be passed to
  489. //           the callback routine.
  490. BOOL WINAPI EnumProcs( PROCENUMPROC lpProc, LPARAM lParam )
  491. {
  492.   OSVERSIONINFO  osver ;
  493.   HANDLE         hSnapShot ;
  494.   PROCESSENTRY32 procentry ;
  495.   BOOL           bFlag ;
  496.  
  497.  
  498.   Log("EnumProcs start");
  499.   // Check to see if were running under Windows95 or
  500.   // Windows NT.
  501.   osver.dwOSVersionInfoSize = sizeof( osver ) ;
  502.   if( !GetVersionEx( &osver ) )
  503.   {
  504.      Log("GetVersionEx failed, EnumProcs end");
  505.      return FALSE ;
  506.   }
  507.  
  508.   // If Windows NT:
  509.   if( osver.dwPlatformId == VER_PLATFORM_WIN32_NT )
  510.   {
  511.     PPERF_INSTANCE  pInstance;
  512.     PPERF_COUNTER   pCounterProcID;
  513.     PPERF_OBJECT    pObject;
  514.     INT             InstanceIndex = 0;
  515.     PPERF_DATA      gpPerfData=NULL;
  516.     TCHAR           INDEX_PROCTHRD_OBJ[20];
  517.     DWORD           gPerfDataSize = 50*1024;
  518.     DWORD           PX_PROCESS;
  519. /*    DWORD           PX_THREAD;*/
  520.     DWORD           *pdwProcID;
  521.     char            procname[MAX_PATH];
  522.  
  523.     Log("Using NT method");
  524.     PX_PROCESS = GetTitleIdx("Process");
  525.     /*PX_THREAD  = GetTitleIdx("Thread");
  526.     wsprintf (INDEX_PROCTHRD_OBJ, TEXT("%ld %ld"), PX_PROCESS, PX_THREAD);*/
  527.     wsprintf (INDEX_PROCTHRD_OBJ, TEXT("%ld"), PX_PROCESS);
  528.     gpPerfData = RefreshPerfData (HKEY_PERFORMANCE_DATA, INDEX_PROCTHRD_OBJ, gpPerfData, &gPerfDataSize);
  529.     pObject = FindObject (gpPerfData, PX_PROCESS);
  530.     if (pObject)
  531.     {
  532.       if ((pCounterProcID = FindCounter(pObject, GetTitleIdx("ID Process"))))
  533.       {
  534.         pInstance = FirstInstance (pObject);
  535.  
  536.         while (pInstance && InstanceIndex < pObject->NumInstances)
  537.         {
  538.           pdwProcID = (DWORD *) CounterData (pInstance, pCounterProcID);
  539.           if (*pdwProcID)
  540.           {
  541.             sprintf(procname,"%S.exe",InstanceName(pInstance));
  542.             Log("procname=%s",procname);
  543.             if (!lpProc( *pdwProcID, 0, procname , lParam))
  544.             {
  545.               LocalFree(gpPerfData);
  546.               Log("EnumProcs end");
  547.               return FALSE ;
  548.             }
  549.           }
  550.           pInstance = NextInstance (pInstance);
  551.           InstanceIndex++;
  552.         }
  553.       }
  554.     }
  555.     LocalFree(gpPerfData);
  556.  
  557.  
  558.   // If Windows 95:
  559.   }
  560.   else if( osver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
  561.   {
  562.  
  563.      Log("Using Win9x method");
  564.      if (hInstLib==NULL)
  565.      {
  566.        hInstLib = LoadLibraryA( "Kernel32.DLL" ) ;
  567.        if( hInstLib == NULL )
  568.           return FALSE ;
  569.  
  570.        // Get procedure addresses.
  571.        // We are linking to these functions of Kernel32
  572.        // explicitly, because otherwise a module using
  573.        // this code would fail to load under Windows NT,
  574.        // which does not have the Toolhelp32
  575.        // functions in the Kernel 32.
  576.        lpfCreateToolhelp32Snapshot=
  577.           (HANDLE(WINAPI *)(DWORD,DWORD))
  578.           GetProcAddress( hInstLib,
  579.           "CreateToolhelp32Snapshot" ) ;
  580.        lpfProcess32First=
  581.           (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
  582.           GetProcAddress( hInstLib, "Process32First" ) ;
  583.        lpfProcess32Next=
  584.           (BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
  585.           GetProcAddress( hInstLib, "Process32Next" ) ;
  586.        lpfModule32First=
  587.           (BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
  588.           GetProcAddress( hInstLib, "Module32First" ) ;
  589.        lpfModule32Next=
  590.           (BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
  591.           GetProcAddress( hInstLib, "Module32Next" ) ;
  592.        if(lpfProcess32Next == NULL ||
  593.           lpfProcess32First == NULL ||
  594.           lpfModule32Next == NULL ||
  595.           lpfModule32First == NULL ||
  596.           lpfCreateToolhelp32Snapshot == NULL )
  597.        {
  598.          Log("Error loading libraries");
  599.           FreeLibrary( hInstLib );
  600.           hInstLib=NULL;
  601.           return FALSE ;
  602.        }
  603.      }
  604.  
  605.      // Get a handle to a Toolhelp snapshot of the systems
  606.      // processes.
  607.      hSnapShot = lpfCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
  608.      if( hSnapShot == INVALID_HANDLE_VALUE )
  609.      {
  610.         Log("CreateToolhelp32Snapshot failed");
  611.         return FALSE ;
  612.      }
  613.  
  614.      // Get the first process' information.
  615.      procentry.dwSize = sizeof(PROCESSENTRY32) ;
  616.      bFlag = lpfProcess32First( hSnapShot, &procentry ) ;
  617.  
  618.      // While there are processes, keep looping.
  619.  
  620.      while( bFlag )
  621.      {
  622.        // Call the enum func with the filename and ProcID.
  623.  
  624.         MODULEENTRY32 me32 = {0}; 
  625.  
  626.         if (GetProcessModule(procentry.th32ProcessID, 
  627.                 procentry.th32ModuleID, &me32, sizeof(MODULEENTRY32)))
  628.         {
  629.            Log("szModule=%s",me32.szModule);
  630.            if(lpProc( procentry.th32ProcessID, 0,
  631.               me32.szModule, lParam ))
  632.            {
  633.              procentry.dwSize = sizeof(PROCESSENTRY32) ;
  634.              bFlag = lpfProcess32Next( hSnapShot, &procentry );
  635.            }
  636.            else
  637.            {
  638.              CloseHandle(hSnapShot);
  639.              Log("EnumProcs end");
  640.              return FALSE;
  641.            }
  642.         }     
  643.      }
  644.      CloseHandle(hSnapShot);
  645.   }
  646.   else
  647.   {
  648.     Log("EnumProcs end (Unknown OS)");
  649.      return FALSE ;
  650.   }
  651.  
  652.   Log("EnumProcs end");
  653.   return TRUE ;
  654. }
  655.  
  656. BOOL WINAPI Enum16( DWORD dwThreadId, WORD hMod16, WORD hTask16,
  657.   PSZ pszModName, PSZ pszFileName, LPARAM lpUserDefined )
  658. {
  659.   BOOL bRet ;
  660.  
  661.   EnumInfoStruct *psInfo = (EnumInfoStruct *)lpUserDefined ;
  662.  
  663.   Log("Enum16 start");
  664.   bRet = psInfo->lpProc( psInfo->dwPID, hTask16, pszFileName,
  665.      psInfo->lParam ) ;
  666.  
  667.   if(!bRet)
  668.   {
  669.      psInfo->bEnd = TRUE ;
  670.   }
  671.  
  672.   Log("Enum16 end (bRet=%d)",(int)bRet);
  673.   return !bRet;
  674. }