Sean/Work
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial

Browse Source
This commit is contained in:
Sean Kessler (Europa)
2024-08-07 09:16:27 -04:00
parent fdfadd5c7e
commit 5f971cf684
5200 changed files with 731717 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

90
psapint/PROCID.HPP Normal file
View File

@@ -0,0 +1,90 @@
#ifndef _PSAPINT_PROCESSID_HPP_
#define _PSAPINT_PROCESSID_HPP_
#ifndef _COMMON_STDIO_HPP_
#include <common/stdio.hpp>
#endif
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_STRING_HPP_
#include <common/string.hpp>
#endif
#ifndef _COMMON_ARRAY_HPP_
#include <common/array.hpp>
#endif
class ProcessID;
typedef Array<ProcessID> ProcessIDList;
class ProcessID
{
public:
ProcessID(void);
ProcessID(const ProcessID &someProcessID);
ProcessID(DWORD processID);
virtual ~ProcessID();
ProcessID &operator=(const ProcessID &someProcessID);
bool operator==(const ProcessID &someProcessID)const;
DWORD processID(void)const;
void processID(DWORD processID);
String toString(void)const;
private:
DWORD mProcessID;
};
inline
ProcessID::ProcessID(void)
: mProcessID(0)
{
}
inline
ProcessID::ProcessID(const ProcessID &someProcessID)
: mProcessID(someProcessID.mProcessID)
{
}
inline
ProcessID::ProcessID(DWORD processID)
: mProcessID(processID)
{
}
inline
ProcessID::~ProcessID()
{
}
inline
ProcessID &ProcessID::operator=(const ProcessID &someProcessID)
{
processID(someProcessID.processID());
return *this;
}
inline
bool ProcessID::operator==(const ProcessID &someProcessID)const
{
return processID()==someProcessID.processID();
}
inline
DWORD ProcessID::processID(void)const
{
return mProcessID;
}
inline
void ProcessID::processID(DWORD processID)
{
mProcessID=processID;
}
inline
String ProcessID::toString(void)const
{
String strProcessID;
::sprintf(strProcessID.str(),"%d(0x%08lx)",mProcessID,mProcessID);
return strProcessID;
}
#endif

82
psapint/PROCINFO.HPP Normal file
View File

@@ -0,0 +1,82 @@
#ifndef _PSAPINT_PROCINFO_HPP_
#define _PSAPINT_PROCINFO_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_ARRAY_HPP_
#include <common/array.hpp>
#endif
#ifndef _PSAPINT_PROCESSID_HPP_
#include <psapint/procid.hpp>
#endif
#ifndef _PSAPINT_MODULEINFO_HPP_
#include <psapint/modinfo.hpp>
#endif
class ProcessInfo;
typedef Array<ProcessInfo> ProcessInfoList;
class ProcessInfo : public ModuleInfoList
{
public:
ProcessInfo(void);
ProcessInfo(const ProcessID &processID);
ProcessInfo(const ProcessInfo &someProcessInfo);
virtual ~ProcessInfo();
ProcessInfo &operator=(const ProcessInfo &someProcessInfo);
bool operator==(const ProcessInfo &someProcessInfo)const;
const ProcessID &processID(void)const;
void processID(const ProcessID &processID);
private:
ProcessID mProcessID;
};
inline
ProcessInfo::ProcessInfo(void)
{
}
inline
ProcessInfo::ProcessInfo(const ProcessInfo &someProcessInfo)
: mProcessID(someProcessInfo.mProcessID), ModuleInfoList(someProcessInfo)
{
}
inline
ProcessInfo::ProcessInfo(const ProcessID &processID)
: mProcessID(processID)
{
}
inline
ProcessInfo::~ProcessInfo()
{
}
inline
ProcessInfo &ProcessInfo::operator=(const ProcessInfo &someProcessInfo)
{
processID(someProcessInfo.processID());
(ModuleInfoList &)*this=(ModuleInfoList &)someProcessInfo;
return *this;
}
inline
bool ProcessInfo::operator==(const ProcessInfo &someProcessInfo)const
{
return (processID()==someProcessInfo.processID()&&
(ModuleInfoList&)*this==(ModuleInfoList&)someProcessInfo);
}
inline
const ProcessID &ProcessInfo::processID(void)const
{
return mProcessID;
}
inline
void ProcessInfo::processID(const ProcessID &processID)
{
mProcessID=processID;
}
#endif

213
psapint/PSAPI.CPP Normal file
View File

@@ -0,0 +1,213 @@
#include <psapint/psapi.hpp>
#include <common/process.hpp>
ProcessAPI::ProcessAPI(void)
: mpfnEnumProcesses(0), mpfnEnumProcessModules(0), mpfnGetModuleBaseName(0), mpfnGetModuleFileNameEx(0),
mpfnGetModuleInformation(0), mpfnEmptyWorkingSet(0), mpfnQueryWorkingSet(0),
mpfnInitializeProcessForWsWatch(0), mpfnGetWsChanges(0), mpfnGetMappedFileName(0),
mpfnEnumDeviceDrivers(0), mpfnGetDeviceDriverBaseName(0), mpfnGetDeviceDriverFileName(0),
mpfnGetProcessMemoryInfo(0), mPSAPILib("PSAPI.DLL")
{
getEntryPoints();
}
ProcessAPI::ProcessAPI(const ProcessAPI &someProcessAPI)
{ // private implementation
*this=someProcessAPI;
}
ProcessAPI::~ProcessAPI()
{
}
ProcessAPI &ProcessAPI::operator=(const ProcessAPI &/*someProcessAPI*/)
{ // private implementation
return *this;
}
bool ProcessAPI::enumProcesses(ProcessInfoList &processInfoList)
{
ProcessIDList processIDList;
String strModuleBaseName;
String strModuleFileName;
processInfoList.size(0);
enumProcesses(processIDList);
processInfoList.size(processIDList.size());
for(int procIndex=0;procIndex<processIDList.size();procIndex++)
{
processInfoList[procIndex]=processIDList[procIndex];
ProcessInfo &processInfo=processInfoList[procIndex];
enumProcessModules(processInfo.processID(),processInfo);
ModuleInfoList &moduleInfoList=processInfo;
for(int modIndex=0;modIndex<moduleInfoList.size();modIndex++)
{
ModuleInfo &moduleInfo=moduleInfoList[modIndex];
getModuleBaseName(processInfo.processID(),moduleInfo.module(),strModuleBaseName);
getModuleFileName(processInfo.processID(),moduleInfo.module(),strModuleFileName);
moduleInfo.moduleBaseName(strModuleBaseName);
moduleInfo.moduleFileName(strModuleFileName);
}
}
return processInfoList.size();
}
bool ProcessAPI::enumProcesses(ProcessIDList &processList)
{
DWORD cbNeeded(0);
DWORD processListArray[1024];
DWORD itemCount;
enumProcesses((unsigned long*)&processListArray,sizeof(processListArray),&cbNeeded);
itemCount=cbNeeded/sizeof(DWORD);
processList.size(itemCount);
for(int index=0;index<itemCount;index++)processList[index]=processListArray[index];
return processList.size()?true:false;
}
bool ProcessAPI::enumProcessModules(const ProcessID &processID,ModuleInfoList &moduleInfoList)
{
Process process;
DWORD cbNeeded(0);
HMODULE moduleHandleArray[1024];
DWORD itemCount;
moduleInfoList.size(0);
if(!process.openProcess(processID.processID()))return false;
enumProcessModules(process.getProcess(),(HMODULE*)&moduleHandleArray,sizeof(moduleHandleArray),&cbNeeded);
itemCount=cbNeeded/sizeof(HANDLE);
moduleInfoList.size(itemCount);
for(int index=0;index<itemCount;index++)moduleInfoList[index]=ModuleInfo(moduleHandleArray[index]);
return moduleInfoList.size()?true:false;
}
DWORD ProcessAPI::getModuleBaseName(const ProcessID &processID,HMODULE hModule,String &strModuleBaseName)
{
Process process;
if(!process.openProcess(processID.processID()))return 0;
strModuleBaseName.reserve(2048);
return getModuleBaseName(process.getProcess(),hModule,strModuleBaseName,2048);
}
DWORD ProcessAPI::getModuleFileName(const ProcessID &processID,HMODULE hModule,String &strModuleFileName)
{
Process process;
if(!process.openProcess(processID.processID()))return 0;
strModuleFileName.reserve(2048);
return getModuleFileNameEx(process.getProcess(),hModule,strModuleFileName,2048);
}
bool ProcessAPI::getEntryPoints(void)
{
if(!mPSAPILib.isOkay())return FALSE;
mpfnEnumProcesses=(PFNENUMPROCESSES)mPSAPILib.procAddress("EnumProcesses");
mpfnEnumProcessModules=(PFNENUMPROCESSMODULES)mPSAPILib.procAddress("EnumProcessModules");
mpfnGetModuleBaseName=(PFNGETMODULEBASENAME)mPSAPILib.procAddress("GetModuleBaseNameA");
mpfnGetModuleFileNameEx=(PFNGETMODULEFILENAMEEX)mPSAPILib.procAddress("GetModuleFileNameExA");
mpfnGetModuleInformation=(PFNGETMODULEINFORMATION)mPSAPILib.procAddress("GetModuleInformation");
mpfnEmptyWorkingSet=(PFNEMPTYWORKINGSET)mPSAPILib.procAddress("EmptyWorkingSet");
mpfnQueryWorkingSet=(PFNQUERYWORKINGSET)mPSAPILib.procAddress("QueryWorkingSet");
mpfnInitializeProcessForWsWatch=(PFNINITIALIZEPROCESSFORWSWATCH)mPSAPILib.procAddress("InitializeProcessForWsWatch");
mpfnGetWsChanges=(PFNGETWSCHANGES)mPSAPILib.procAddress("GetWsChanges");
mpfnGetMappedFileName=(PFNGETMAPPEDFILENAME)mPSAPILib.procAddress("GetMappedFileNameA");
mpfnEnumDeviceDrivers=(PFNENUMDEVICEDRIVERS)mPSAPILib.procAddress("EnumDeviceDrivers");
mpfnGetDeviceDriverBaseName=(PFNGETDEVICEDRIVERBASENAME)mPSAPILib.procAddress("GetDeviceDriverBaseNameA");
mpfnGetDeviceDriverFileName=(PFNGETDEVICEDRIVERFILENAME)mPSAPILib.procAddress("GetDeviceDriverFileNameA");
mpfnGetProcessMemoryInfo=(PFNGETPROCESSMEMORYINFO)mPSAPILib.procAddress("GetProcessMemoryInfo");
return isOkay();
}
bool ProcessAPI::enumProcesses(DWORD *lpidProcess,DWORD cb,DWORD *cbNeeded)
{
if(!mpfnEnumProcesses){throw ProcessAPIInvalidEntryPoint();return false;}
return mpfnEnumProcesses(lpidProcess,cb,cbNeeded);
}
bool ProcessAPI::enumProcessModules(HANDLE hProcess,HMODULE *lphModule,DWORD cb,LPDWORD lpcbNeeded)
{
if(!mpfnEnumProcessModules){throw ProcessAPIInvalidEntryPoint();return false;}
return mpfnEnumProcessModules(hProcess,lphModule,cb,lpcbNeeded);
}
DWORD ProcessAPI::getModuleBaseName(HANDLE hProcess,HMODULE hModule,LPSTR lpBaseName,DWORD nSize)
{
if(!mpfnGetModuleBaseName){throw ProcessAPIInvalidEntryPoint();return 0;}
return mpfnGetModuleBaseName(hProcess,hModule,lpBaseName,nSize);
}
DWORD ProcessAPI::getModuleFileNameEx(HANDLE hProcess,HMODULE hModule,LPSTR lpFilename,DWORD nSize)
{
if(!mpfnGetModuleFileNameEx){throw ProcessAPIInvalidEntryPoint();return 0;}
return mpfnGetModuleFileNameEx(hProcess,hModule,lpFilename,nSize);
}
bool ProcessAPI::getModuleInformation(HANDLE hProcess,HMODULE hModule,LPMODULEINFO lpmodinfo,DWORD cb)
{
if(!mpfnGetModuleInformation){throw ProcessAPIInvalidEntryPoint();return false;}
return mpfnGetModuleInformation(hProcess,hModule,lpmodinfo,cb);
}
bool ProcessAPI::emptyWorkingSet(HANDLE hProcess)
{
if(!mpfnEmptyWorkingSet){throw ProcessAPIInvalidEntryPoint();return false;}
return mpfnEmptyWorkingSet(hProcess);
}
bool ProcessAPI::queryWorkingSet(HANDLE hProcess,PVOID pv,DWORD cb)
{
if(!mpfnQueryWorkingSet){throw ProcessAPIInvalidEntryPoint();return false;}
return mpfnQueryWorkingSet(hProcess,pv,cb);
}
bool ProcessAPI::initializeProcessForWsWatch(HANDLE hProcess)
{
if(!mpfnInitializeProcessForWsWatch){throw ProcessAPIInvalidEntryPoint();return false;}
return mpfnInitializeProcessForWsWatch(hProcess);
}
bool ProcessAPI::getWsChanges(HANDLE hProcess,PPSAPI_WS_WATCH_INFORMATION lpWatchInfo,DWORD cb)
{
if(!mpfnGetWsChanges){throw ProcessAPIInvalidEntryPoint();return false;}
return mpfnGetWsChanges(hProcess,lpWatchInfo,cb);
}
DWORD ProcessAPI::getMappedFileName(HANDLE hProcess,LPVOID lpv,LPWSTR lpFilename,DWORD nSize)
{
if(!mpfnGetMappedFileName){throw ProcessAPIInvalidEntryPoint();return 0;}
return mpfnGetMappedFileName(hProcess,lpv,lpFilename,nSize);
}
DWORD ProcessAPI::enumDeviceDrivers(LPVOID *lpImageBase,DWORD cb,LPDWORD lpcbNeeded)
{
if(!mpfnEnumDeviceDrivers){throw ProcessAPIInvalidEntryPoint();return 0;}
return mpfnEnumDeviceDrivers(lpImageBase,cb,lpcbNeeded);
}
DWORD ProcessAPI::getDeviceDriverBaseName(LPVOID imageBase,LPSTR lpBaseName,DWORD nSize)
{
if(!mpfnGetDeviceDriverBaseName){throw ProcessAPIInvalidEntryPoint();return 0;}
return mpfnGetDeviceDriverBaseName(imageBase,lpBaseName,nSize);
}
DWORD ProcessAPI::getDeviceDriverFileName(LPVOID imageBase,LPSTR lpFilename,DWORD nSize)
{
if(!mpfnGetDeviceDriverFileName){throw ProcessAPIInvalidEntryPoint();return 0;}
return mpfnGetDeviceDriverFileName(imageBase,lpFilename,nSize);
}
bool ProcessAPI::getProcessMemoryInfo(HANDLE hProcess,PPROCESS_MEMORY_COUNTERS ppsmemCounters,DWORD cb)
{
if(!mpfnGetProcessMemoryInfo){throw ProcessAPIInvalidEntryPoint();return false;}
return mpfnGetProcessMemoryInfo(hProcess,ppsmemCounters,cb);
}
bool ProcessAPI::isOkay(void)const
{
if(!mPSAPILib.isOkay()||!mpfnEnumProcesses||!mpfnEnumProcessModules||!mpfnGetModuleBaseName||
!mpfnGetModuleFileNameEx||!mpfnGetModuleInformation||!mpfnEmptyWorkingSet||!mpfnQueryWorkingSet||
!mpfnInitializeProcessForWsWatch||!mpfnGetWsChanges||!mpfnGetMappedFileName||!mpfnEnumDeviceDrivers||
!mpfnGetDeviceDriverBaseName||!mpfnGetDeviceDriverFileName||!mpfnGetProcessMemoryInfo)return FALSE;
return TRUE;
}

88
psapint/PSAPI.HPP Normal file
View File

@@ -0,0 +1,88 @@
#ifndef _PSAPINT_PSAPI_HPP_
#define _PSAPINT_PSAPI_HPP_
#ifndef _COMMON_LIBRARY_HPP_
#include <common/library.hpp>
#endif
#ifndef _PSAPINT_PROCESSID_HPP_
#include <psapint/procid.hpp>
#endif
#ifndef _PSAPINT_PROCINFO_HPP_
#include <psapint/procinfo.hpp>
#endif
#ifndef _PSAPINT_PROCESSMEMORYCOUNTERS_HPP_
#include <psapint/memcnt.hpp>
#endif
#ifndef _PSAPI_H_
#include <psapi/psapi.h>
#endif
class ProcessAPI
{
public:
class ProcessAPIInvalidEntryPoint{};
ProcessAPI(void);
virtual ~ProcessAPI();
bool enumProcesses(ProcessInfoList &processInfoList);
bool enumProcesses(ProcessIDList &processList);
bool enumProcessModules(const ProcessID &processID,ModuleInfoList &moduleInfoList);
DWORD getModuleBaseName(const ProcessID &processID,HMODULE hModule,String &strModuleBaseName);
DWORD getModuleFileName(const ProcessID &processID,HMODULE hModule,String &strModuleFileName);
bool getProcessMemoryInfo(HANDLE hProcess,ProcessMemoryCounters &processMemoryCounters);
bool isOkay(void)const;
private:
typedef BOOL (WINAPI *PFNENUMPROCESSES)(DWORD *lpidProcess,DWORD cb,DWORD *cbNeeded);
typedef BOOL (WINAPI *PFNENUMPROCESSMODULES)(HANDLE hProcess,HMODULE *lphModule,DWORD cb,LPDWORD lpcbNeeded);
typedef DWORD (WINAPI *PFNGETMODULEBASENAME)(HANDLE hProcess,HMODULE hModule,LPSTR lpBaseName,DWORD nSize);
typedef DWORD (WINAPI *PFNGETMODULEFILENAMEEX)(HANDLE hProcess,HMODULE hModule,LPSTR lpFilename,DWORD nSize);
typedef BOOL (WINAPI *PFNGETMODULEINFORMATION)(HANDLE hProcess,HMODULE hModule,LPMODULEINFO lpmodinfo,DWORD cb);
typedef BOOL (WINAPI *PFNEMPTYWORKINGSET)(HANDLE hProcess);
typedef BOOL (WINAPI *PFNQUERYWORKINGSET)(HANDLE hProcess,PVOID pv,DWORD cb);
typedef BOOL (WINAPI *PFNINITIALIZEPROCESSFORWSWATCH)(HANDLE hProcess);
typedef BOOL (WINAPI *PFNGETWSCHANGES)(HANDLE hProcess,PPSAPI_WS_WATCH_INFORMATION lpWatchInfo,DWORD cb);
typedef DWORD (WINAPI *PFNGETMAPPEDFILENAME)(HANDLE hProcess,LPVOID lpv,LPWSTR lpFilename,DWORD nSize);
typedef DWORD (WINAPI *PFNENUMDEVICEDRIVERS)(LPVOID *lpImageBase,DWORD cb,LPDWORD lpcbNeeded);
typedef DWORD (WINAPI *PFNGETDEVICEDRIVERBASENAME)(LPVOID imageBase,LPSTR lpBaseName,DWORD nSize);
typedef DWORD (WINAPI *PFNGETDEVICEDRIVERFILENAME)(LPVOID imageBase,LPSTR lpFilename,DWORD nSize);
typedef BOOL (WINAPI *PFNGETPROCESSMEMORYINFO)(HANDLE hProcess,PPROCESS_MEMORY_COUNTERS ppsmemCounters,DWORD cb);
ProcessAPI(const ProcessAPI &someProcessAPI);
ProcessAPI &operator=(const ProcessAPI &someProcessAPI);
bool getEntryPoints(void);
bool enumProcesses(DWORD *lpidProcess,DWORD cb,DWORD *cbNeeded);
bool enumProcessModules(HANDLE hProcess,HMODULE *lphModule,DWORD cb,LPDWORD lpcbNeeded);
DWORD getModuleBaseName(HANDLE hProcess,HMODULE hModule,LPSTR lpBaseName,DWORD nSize);
DWORD getModuleFileNameEx(HANDLE hProcess,HMODULE hModule,LPSTR lpFilename,DWORD nSize);
bool emptyWorkingSet(HANDLE hProcess);
bool queryWorkingSet(HANDLE hProcess,PVOID pv,DWORD cb);
bool initializeProcessForWsWatch(HANDLE hProcess);
bool getWsChanges(HANDLE hProcess,PPSAPI_WS_WATCH_INFORMATION lpWatchInfo,DWORD cb);
DWORD getMappedFileName(HANDLE hProcess,LPVOID lpv,LPWSTR lpFilename,DWORD nSize);
DWORD enumDeviceDrivers(LPVOID *lpImageBase,DWORD cb,LPDWORD lpcbNeeded);
DWORD getDeviceDriverBaseName(LPVOID imageBase,LPSTR lpBaseName,DWORD nSize);
DWORD getDeviceDriverFileName(LPVOID imageBase,LPSTR lpFilename,DWORD nSize);
bool getProcessMemoryInfo(HANDLE hProcess,PPROCESS_MEMORY_COUNTERS ppsmemCounters,DWORD cb);
bool getModuleInformation(HANDLE hProcess,HMODULE hModule,LPMODULEINFO lpmodinfo,DWORD cb);
PFNENUMPROCESSES mpfnEnumProcesses;
PFNENUMPROCESSMODULES mpfnEnumProcessModules;
PFNGETMODULEBASENAME mpfnGetModuleBaseName;
PFNGETMODULEFILENAMEEX mpfnGetModuleFileNameEx;
PFNGETMODULEINFORMATION mpfnGetModuleInformation;
PFNEMPTYWORKINGSET mpfnEmptyWorkingSet;
PFNQUERYWORKINGSET mpfnQueryWorkingSet;
PFNINITIALIZEPROCESSFORWSWATCH mpfnInitializeProcessForWsWatch;
PFNGETWSCHANGES mpfnGetWsChanges;
PFNGETMAPPEDFILENAME mpfnGetMappedFileName;
PFNENUMDEVICEDRIVERS mpfnEnumDeviceDrivers;
PFNGETDEVICEDRIVERBASENAME mpfnGetDeviceDriverBaseName;
PFNGETDEVICEDRIVERFILENAME mpfnGetDeviceDriverFileName;
PFNGETPROCESSMEMORYINFO mpfnGetProcessMemoryInfo;
Library mPSAPILib;
};
inline
bool ProcessAPI::getProcessMemoryInfo(HANDLE hProcess,ProcessMemoryCounters &processMemoryCounters)
{
return getProcessMemoryInfo(hProcess,&processMemoryCounters.getPROCESSMEMORYCOUNTERS(),ProcessMemoryCounters::size());
}
#endif

29
psapint/PSAPINT.DSW Normal file
View File

@@ -0,0 +1,29 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "psapint"=.\psapint.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

BIN
psapint/PSAPINT.OPT Normal file
View File

Binary file not shown.

29
psapint/PSAPINT.PLG Normal file
View File

@@ -0,0 +1,29 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: psapint - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
Creating temporary file "C:\DOCUME~1\sean\LOCALS~1\Temp\RSP2.tmp" with contents
[
/nologo /Gz /MTd /GX /Z7 /Od /I "\work" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /Fp"msvcobj/psapint.pch" /YX /Fo"msvcobj/" /Fd"msvcobj/" /FD /c
"D:\work\psapint\psapi.cpp"
"D:\work\psapint\psapi95.cpp"
]
Creating command line "cl.exe @C:\DOCUME~1\sean\LOCALS~1\Temp\RSP2.tmp"
Creating command line "link.exe -lib /nologo /out:"..\exe\psapint.lib" .\msvcobj\psapi.obj .\msvcobj\psapi95.obj "
<h3>Output Window</h3>
Compiling...
psapi.cpp
psapi95.cpp
Creating library...
<h3>Results</h3>
psapint.lib - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

181
psapint/memcnt.hpp Normal file
View File

@@ -0,0 +1,181 @@
#ifndef _PSAPINT_PROCESSMEMORYCOUNTERS_HPP_
#define _PSAPINT_PROCESSMEMORYCOUNTERS_HPP_
#ifndef _PSAPI_H_
#include <psapi/psapi.h>
#endif
class ProcessMemoryCounters : private PROCESS_MEMORY_COUNTERS
{
public:
ProcessMemoryCounters(void);
virtual ~ProcessMemoryCounters();
DWORD pageFaultCount(void)const;
void pageFaultCount(DWORD pageFaultCount);
DWORD peakWorkingSetSize(void)const;
void peakWorkingSetSize(DWORD peakWorkingSetSize);
DWORD workingSetSize(void)const;
void workingSetSize(DWORD workingSetSize);
DWORD quotaPeakPagedPoolUsage(void)const;
void quotaPeakPagedPoolUsage(DWORD quotaPeakPagedPoolUsage);
DWORD quotaPagedPoolUsage(void)const;
void quotaPagedPoolUsage(DWORD quotaPagedPoolUsage);
DWORD quotaPeakedNonPagedPoolUsage(void)const;
void quotaPeakedNonPagedPoolUsage(DWORD quotaPeakedNonPagedPoolUsage);
DWORD quotaNonPagedPoolUsage(void)const;
void quotaNonPagedPoolUsage(DWORD quotaNonPagedPoolUsage);
DWORD pageFileUsage(void)const;
void pageFileUsage(DWORD pageFileUsage);
DWORD peakPageFileUsage(void)const;
void peakPageFileUsage(DWORD peakPageFileUsage);
PROCESS_MEMORY_COUNTERS &getPROCESSMEMORYCOUNTERS(void);
static DWORD size(void);
private:
void zeroInit(void);
};
inline
ProcessMemoryCounters::ProcessMemoryCounters(void)
{
zeroInit();
}
inline
ProcessMemoryCounters::~ProcessMemoryCounters()
{
}
inline
DWORD ProcessMemoryCounters::pageFaultCount(void)const
{
return PROCESS_MEMORY_COUNTERS::PageFaultCount;
}
inline
void ProcessMemoryCounters::pageFaultCount(DWORD pageFaultCount)
{
PROCESS_MEMORY_COUNTERS::PageFaultCount=pageFaultCount;
}
inline
DWORD ProcessMemoryCounters::peakWorkingSetSize(void)const
{
return PROCESS_MEMORY_COUNTERS::PeakWorkingSetSize;
}
inline
void ProcessMemoryCounters::peakWorkingSetSize(DWORD peakWorkingSetSize)
{
PROCESS_MEMORY_COUNTERS::PeakWorkingSetSize=peakWorkingSetSize;
}
inline
DWORD ProcessMemoryCounters::workingSetSize(void)const
{
return PROCESS_MEMORY_COUNTERS::WorkingSetSize;
}
inline
void ProcessMemoryCounters::workingSetSize(DWORD workingSetSize)
{
PROCESS_MEMORY_COUNTERS::WorkingSetSize=workingSetSize;
}
inline
DWORD ProcessMemoryCounters::quotaPeakPagedPoolUsage(void)const
{
return PROCESS_MEMORY_COUNTERS::QuotaPeakPagedPoolUsage;
}
inline
void ProcessMemoryCounters::quotaPeakPagedPoolUsage(DWORD quotaPeakPagedPoolUsage)
{
PROCESS_MEMORY_COUNTERS::QuotaPeakPagedPoolUsage=quotaPeakPagedPoolUsage;
}
inline
DWORD ProcessMemoryCounters::quotaPagedPoolUsage(void)const
{
return PROCESS_MEMORY_COUNTERS::QuotaPagedPoolUsage;
}
inline
void ProcessMemoryCounters::quotaPagedPoolUsage(DWORD quotaPagedPoolUsage)
{
PROCESS_MEMORY_COUNTERS::QuotaPagedPoolUsage=quotaPagedPoolUsage;
}
inline
DWORD ProcessMemoryCounters::quotaPeakedNonPagedPoolUsage(void)const
{
return PROCESS_MEMORY_COUNTERS::QuotaPeakNonPagedPoolUsage;
}
inline
void ProcessMemoryCounters::quotaPeakedNonPagedPoolUsage(DWORD quotaPeakedNonPagedPoolUsage)
{
PROCESS_MEMORY_COUNTERS::QuotaPeakNonPagedPoolUsage=quotaPeakedNonPagedPoolUsage;
}
inline
DWORD ProcessMemoryCounters::quotaNonPagedPoolUsage(void)const
{
return PROCESS_MEMORY_COUNTERS::QuotaNonPagedPoolUsage;
}
inline
void ProcessMemoryCounters::quotaNonPagedPoolUsage(DWORD quotaNonPagedPoolUsage)
{
PROCESS_MEMORY_COUNTERS::QuotaNonPagedPoolUsage=quotaNonPagedPoolUsage;
}
inline
DWORD ProcessMemoryCounters::pageFileUsage(void)const
{
return PROCESS_MEMORY_COUNTERS::PagefileUsage;
}
inline
void ProcessMemoryCounters::pageFileUsage(DWORD pageFileUsage)
{
PROCESS_MEMORY_COUNTERS::PagefileUsage=pageFileUsage;
}
inline
DWORD ProcessMemoryCounters::peakPageFileUsage(void)const
{
return PROCESS_MEMORY_COUNTERS::PeakPagefileUsage;
}
inline
void ProcessMemoryCounters::peakPageFileUsage(DWORD peakPageFileUsage)
{
PROCESS_MEMORY_COUNTERS::PeakPagefileUsage;
}
inline
void ProcessMemoryCounters::zeroInit(void)
{
PROCESS_MEMORY_COUNTERS::cb=size();
PROCESS_MEMORY_COUNTERS::PageFaultCount=0;
PROCESS_MEMORY_COUNTERS::PeakWorkingSetSize=0;
PROCESS_MEMORY_COUNTERS::WorkingSetSize=0;
PROCESS_MEMORY_COUNTERS::QuotaPeakPagedPoolUsage=0;
PROCESS_MEMORY_COUNTERS::QuotaPagedPoolUsage=0;
PROCESS_MEMORY_COUNTERS::QuotaPeakNonPagedPoolUsage=0;
PROCESS_MEMORY_COUNTERS::QuotaNonPagedPoolUsage=0;
PROCESS_MEMORY_COUNTERS::PagefileUsage=0;
PROCESS_MEMORY_COUNTERS::PeakPagefileUsage=0;
}
inline
PROCESS_MEMORY_COUNTERS &ProcessMemoryCounters::getPROCESSMEMORYCOUNTERS(void)
{
return *this;
}
inline
DWORD ProcessMemoryCounters::size(void)
{
return sizeof(PROCESS_MEMORY_COUNTERS);
}
#endif

174
psapint/modentry.hpp Normal file
View File

@@ -0,0 +1,174 @@
#ifndef _PSAPINT_MODENTRY_HPP_
#define _PSAPINT_MODENTRY_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_TOOLHELP32_HPP_
#include <common/tlhelp32.hpp>
#endif
class ModuleEntry : private MODULEENTRY32
{
public:
ModuleEntry(void);
virtual ~ModuleEntry();
DWORD moduleID(void)const;
void moduleID(DWORD moduleID);
DWORD processID(void)const;
void processID(DWORD processID);
DWORD globalCntUsage(void)const;
void globalCntIUsage(DWORD globalCntUsage);
DWORD procCntUsage(void)const;
void procCntUsage(DWORD procCntUsage);
DWORD modBaseAddress(void)const;
void modBaseAddress(DWORD modBaseAddress);
DWORD modBaseSize(void)const;
void modBaseSize(DWORD modBaseSize);
HMODULE module(void)const;
void module(HMODULE hModule);
String strModule(void)const;
void szModule(const String &strModule);
String strExePath(void)const;
void strExePath(const String &strExePath);
MODULEENTRY32 &getMODULEENTRY(void);
private:
void zeroInit(void);
};
inline
ModuleEntry::ModuleEntry(void)
{
zeroInit();
}
inline
ModuleEntry::~ModuleEntry()
{
}
inline
DWORD ModuleEntry::moduleID(void)const
{
return MODULEENTRY32::th32ModuleID;
}
inline
void ModuleEntry::moduleID(DWORD moduleID)
{
MODULEENTRY32::th32ModuleID=moduleID;
}
inline
DWORD ModuleEntry::processID(void)const
{
return MODULEENTRY32::th32ProcessID;
}
inline
void ModuleEntry::processID(DWORD processID)
{
MODULEENTRY32::th32ProcessID=processID;
}
inline
DWORD ModuleEntry::globalCntUsage(void)const
{
return MODULEENTRY32::GlblcntUsage;
}
inline
void ModuleEntry::globalCntIUsage(DWORD globalCntUsage)
{
MODULEENTRY32::GlblcntUsage=globalCntUsage;
}
inline
DWORD ModuleEntry::procCntUsage(void)const
{
return MODULEENTRY32::ProccntUsage;
}
inline
void ModuleEntry::procCntUsage(DWORD procCntUsage)
{
MODULEENTRY32::ProccntUsage=procCntUsage;
}
inline
DWORD ModuleEntry::modBaseAddress(void)const
{
return DWORD(MODULEENTRY32::modBaseAddr);
}
inline
void ModuleEntry::modBaseAddress(DWORD modBaseAddress)
{
MODULEENTRY32::modBaseAddr=(BYTE*)modBaseAddress;
}
inline
DWORD ModuleEntry::modBaseSize(void)const
{
return MODULEENTRY32::modBaseSize;
}
inline
void ModuleEntry::modBaseSize(DWORD modBaseSize)
{
MODULEENTRY32::modBaseSize=modBaseSize;
}
inline
HMODULE ModuleEntry::module(void)const
{
return MODULEENTRY32::hModule;
}
inline
void ModuleEntry::module(HMODULE hModule)
{
MODULEENTRY32::hModule=hModule;
}
inline
String ModuleEntry::strModule(void)const
{
return MODULEENTRY32::szModule;
}
inline
void ModuleEntry::szModule(const String &strModule)
{
int strLen(strModule.length());
if(strLen<=MAX_MODULE_NAME32)::strcpy(MODULEENTRY32::szModule,(LPSTR)(String&)strModule);
else {::strncpy(MODULEENTRY32::szModule,(LPSTR)(String&)strModule,MAX_MODULE_NAME32);MODULEENTRY32::szModule[MAX_MODULE_NAME32]=0;}
}
inline
String ModuleEntry::strExePath(void)const
{
return MODULEENTRY32::szExePath;
}
inline
void ModuleEntry::strExePath(const String &strExePath)
{
int strLen(strExePath.length());
if(strLen<MAX_PATH)::strcpy(MODULEENTRY32::szExePath,(LPSTR)(String&)strExePath);
else {::strncpy(MODULEENTRY32::szExePath,(LPSTR)(String&)strExePath,MAX_PATH-1);MODULEENTRY32::szExePath[MAX_PATH-1]=0;}
}
inline
MODULEENTRY32 &ModuleEntry::getMODULEENTRY(void)
{
return *this;
}
inline
void ModuleEntry::zeroInit(void)
{
::memset(&getMODULEENTRY(),0,sizeof(MODULEENTRY32));
MODULEENTRY32::dwSize=sizeof(MODULEENTRY32);
}
#endif

111
psapint/modinfo.hpp Normal file
View File

@@ -0,0 +1,111 @@
#ifndef _PSAPINT_MODULEINFO_HPP_
#define _PSAPINT_MODULEINFO_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_ARRAY_HPP_
#include <common/array.hpp>
#endif
class ModuleInfo;
typedef Array<ModuleInfo> ModuleInfoList;
class ModuleInfo
{
public:
ModuleInfo(void);
ModuleInfo(const ModuleInfo &someModuleInfo);
ModuleInfo(HMODULE hModule,const String &strModuleBaseName=String(),const String &strModuleFileName=String());
virtual ~ModuleInfo();
ModuleInfo &operator=(const ModuleInfo &someModuleInfo);
bool operator==(const ModuleInfo &someModuleInfo)const;
HMODULE module(void)const;
void module(HMODULE hModule);
const String &moduleBaseName(void)const;
void moduleBaseName(const String &strModuleBaseName);
const String &moduleFileName(void)const;
void moduleFileName(const String &strModuleFileName);
private:
HMODULE mhModule;
String mModuleBaseName;
String mModuleFileName;
};
inline
ModuleInfo::ModuleInfo(void)
: mhModule(0)
{
}
inline
ModuleInfo::ModuleInfo(const ModuleInfo &someModuleInfo)
: mhModule(someModuleInfo.mhModule), mModuleBaseName(someModuleInfo.mModuleBaseName),
mModuleFileName(someModuleInfo.mModuleFileName)
{
}
inline
ModuleInfo::ModuleInfo(HMODULE hModule,const String &strModuleBaseName,const String &strModuleFileName)
: mhModule(hModule), mModuleBaseName(strModuleBaseName), mModuleFileName(strModuleFileName)
{
}
inline
ModuleInfo::~ModuleInfo()
{
}
inline
ModuleInfo &ModuleInfo::operator=(const ModuleInfo &someModuleInfo)
{
module(someModuleInfo.module());
moduleBaseName(someModuleInfo.moduleBaseName());
moduleFileName(someModuleInfo.moduleFileName());
return *this;
}
inline
bool ModuleInfo::operator==(const ModuleInfo &someModuleInfo)const
{
return (module()==someModuleInfo.module()&&
moduleBaseName()==someModuleInfo.moduleBaseName()&&
moduleFileName()==someModuleInfo.moduleFileName());
}
inline
HMODULE ModuleInfo::module(void)const
{
return mhModule;
}
inline
void ModuleInfo::module(HMODULE hModule)
{
mhModule=hModule;
}
inline
const String &ModuleInfo::moduleBaseName(void)const
{
return mModuleBaseName;
}
inline
void ModuleInfo::moduleBaseName(const String &strModuleBaseName)
{
mModuleBaseName=strModuleBaseName;
}
inline
const String &ModuleInfo::moduleFileName(void)const
{
return mModuleFileName;
}
inline
void ModuleInfo::moduleFileName(const String &strModuleFileName)
{
mModuleFileName=strModuleFileName;
}
#endif

171
psapint/procentry.hpp Normal file
View File

@@ -0,0 +1,171 @@
#ifndef _PSAPINT_PROCESSENTRY_HPP_
#define _PSAPINT_PROCESSENTRY_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_TOOLHELP32_HPP_
#include <common/tlhelp32.hpp>
#endif
class ProcessEntry : private PROCESSENTRY32
{
public:
ProcessEntry(void);
virtual ~ProcessEntry();
DWORD cntUsage(void)const;
void cntUsage(DWORD cntUsage);
DWORD processID(void)const;
void processID(DWORD processID);
DWORD heapID(void)const;
void heapID(DWORD heapID);
DWORD moduleID(void)const;
void moduleID(DWORD moduleID);
DWORD cntThreads(void)const;
void cntThreads(DWORD cntThreads);
DWORD parentProcessID(void)const;
void parentProcessID(DWORD parentProcessID);
LONG priClassBase(void)const;
void priClassBase(LONG priClassBase);
DWORD flags(void)const;
void flags(DWORD flags);
String strExeFile(void)const;
void strExeFile(const String &strExeFile);
PROCESSENTRY32 &getPROCESSENTRY(void);
private:
void zeroInit(void);
};
inline
ProcessEntry::ProcessEntry(void)
{
zeroInit();
}
inline
ProcessEntry::~ProcessEntry()
{
}
inline
DWORD ProcessEntry::cntUsage(void)const
{
return PROCESSENTRY32::cntUsage;
}
inline
void ProcessEntry::cntUsage(DWORD cntUsage)
{
PROCESSENTRY32::cntUsage=cntUsage;
}
inline
DWORD ProcessEntry::processID(void)const
{
return PROCESSENTRY32::th32ProcessID;
}
inline
void ProcessEntry::processID(DWORD processID)
{
PROCESSENTRY32::th32ProcessID=processID;
}
inline
DWORD ProcessEntry::heapID(void)const
{
return PROCESSENTRY32::th32DefaultHeapID;
}
inline
void ProcessEntry::heapID(DWORD heapID)
{
PROCESSENTRY32::th32DefaultHeapID=heapID;
}
inline
DWORD ProcessEntry::moduleID(void)const
{
return PROCESSENTRY32::th32ModuleID;
}
inline
void ProcessEntry::moduleID(DWORD moduleID)
{
PROCESSENTRY32::th32ModuleID=moduleID;
}
inline
DWORD ProcessEntry::cntThreads(void)const
{
return PROCESSENTRY32::cntThreads;
}
inline
void ProcessEntry::cntThreads(DWORD cntThreads)
{
PROCESSENTRY32::cntThreads=cntThreads;
}
inline
DWORD ProcessEntry::parentProcessID(void)const
{
return PROCESSENTRY32::th32ParentProcessID;
}
inline
void ProcessEntry::parentProcessID(DWORD parentProcessID)
{
PROCESSENTRY32::th32ParentProcessID=parentProcessID;
}
inline
LONG ProcessEntry::priClassBase(void)const
{
return PROCESSENTRY32::pcPriClassBase;
}
inline
void ProcessEntry::priClassBase(LONG priClassBase)
{
PROCESSENTRY32::pcPriClassBase=priClassBase;
}
inline
DWORD ProcessEntry::flags(void)const
{
return PROCESSENTRY32::dwFlags;
}
inline
void ProcessEntry::flags(DWORD flags)
{
PROCESSENTRY32::dwFlags=flags;
}
inline
String ProcessEntry::strExeFile(void)const
{
return PROCESSENTRY32::szExeFile;
}
inline
void ProcessEntry::strExeFile(const String &strExeFile)
{
int strLen(strExeFile.length());
if(strLen<MAX_PATH)::strcpy(PROCESSENTRY32::szExeFile,(LPSTR)(String&)strExeFile);
else {::strncpy(PROCESSENTRY32::szExeFile,(LPSTR)(String&)strExeFile,MAX_PATH-1);PROCESSENTRY32::szExeFile[MAX_PATH-1]=0;}
}
inline
PROCESSENTRY32 &ProcessEntry::getPROCESSENTRY(void)
{
return *this;
}
inline
void ProcessEntry::zeroInit(void)
{
::memset(&getPROCESSENTRY(),0,sizeof(PROCESSENTRY32));
PROCESSENTRY32::dwSize=sizeof(PROCESSENTRY32);
}
#endif

104
psapint/psapi95.cpp Normal file
View File

@@ -0,0 +1,104 @@
#include <psapint/psapi95.hpp>
#include <psapint/procentry.hpp>
#include <psapint/modentry.hpp>
#include <common/block.hpp>
ProcessAPI95::ProcessAPI95(void)
: mpfnProcess32First(0), mpfnProcess32Next(0), mpfnModule32First(0), mpfnModule32Next(0),
mpfnCreateToolhelp32Snapshot(0), mLibrary("KERNEL32.DLL")
{
if(!mLibrary.isOkay())return;
mpfnProcess32First=(PFNPROCESS32FIRST)mLibrary.procAddress("Process32First");
mpfnProcess32Next=(PFNPROCESS32NEXT)mLibrary.procAddress("Process32Next");
mpfnModule32First=(PFNMODULE32FIRST)mLibrary.procAddress("Module32First");
mpfnModule32Next=(PFNMODULE32NEXT)mLibrary.procAddress("Module32Next");
mpfnCreateToolhelp32Snapshot=(PFNCREATETOOLHELP32SNAPSHOT)mLibrary.procAddress("CreateToolhelp32Snapshot");
}
ProcessAPI95::ProcessAPI95(const ProcessAPI95 &/*someProcessAPI*/)
{ // private implementation
}
ProcessAPI95::~ProcessAPI95()
{
}
ProcessAPI95 &ProcessAPI95::operator=(const ProcessAPI95 &/*someProcessAPI*/)
{ // private implementation
return *this;
}
bool ProcessAPI95::enumProcesses(ProcessInfoList &processInfoList)
{
ProcessEntry processEntry;
Block<ProcessInfo> processInfoBlock;
HANDLE hSnapshot;
processInfoList.size(0);
if(!isOkay())return false;
hSnapshot=mpfnCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS|TH32CS_SNAPMODULE,0);
if(-1==(int)hSnapshot)return false;
if(mpfnProcess32First(hSnapshot,&processEntry.getPROCESSENTRY()))
{
processInfoBlock.insert(&ProcessInfo());
ProcessInfo &processInfo=processInfoBlock[processInfoBlock.size()-1];
processInfo.processID(processEntry.processID());
enumProcessModules(processInfo.processID(),processEntry,processInfo);
while(mpfnProcess32Next(hSnapshot,&processEntry.getPROCESSENTRY()))
{
processInfoBlock.insert(&ProcessInfo());
ProcessInfo &processInfo=processInfoBlock[processInfoBlock.size()-1];
processInfo.processID(processEntry.processID());
enumProcessModules(processInfo.processID(),processEntry,processInfo);
}
}
::CloseHandle(hSnapshot);
processInfoList.size(processInfoBlock.size());
for(int index=0;index<processInfoBlock.size();index++)processInfoList[index]=processInfoBlock[index];
return processInfoList.size()?true:false;
}
bool ProcessAPI95::enumProcessModules(const ProcessID &processID,ProcessEntry &processEntry,ModuleInfoList &moduleInfoList)
{
ModuleEntry moduleEntry;
Block<ModuleInfo> moduleInfoBlock;
HANDLE hSnapshot;
moduleInfoList.size(0);
if(!isOkay())return false;
hSnapshot=mpfnCreateToolhelp32Snapshot(TH32CS_SNAPMODULE,processID.processID());
moduleEntry.processID(processID.processID());
moduleInfoBlock.insert(&ModuleInfo());
ModuleInfo &moduleInfo=moduleInfoBlock[moduleInfoBlock.size()-1];
moduleInfo.module((HINSTANCE)processID.processID());
moduleInfo.moduleBaseName(processEntry.strExeFile());
moduleInfo.moduleFileName(processEntry.strExeFile());
if(mpfnModule32First(hSnapshot,&moduleEntry.getMODULEENTRY()))
{
if(!(moduleEntry.strExePath()==processEntry.strExeFile()))
{
moduleInfoBlock.insert(&ModuleInfo());
ModuleInfo &moduleInfo=moduleInfoBlock[moduleInfoBlock.size()-1];
moduleInfo.module(moduleEntry.module());
moduleInfo.moduleBaseName(moduleEntry.strModule());
moduleInfo.moduleFileName(moduleEntry.strExePath());
}
moduleEntry.processID(processID.processID());
while(mpfnModule32Next(hSnapshot,&moduleEntry.getMODULEENTRY()))
{
if(!(moduleEntry.strExePath()==processEntry.strExeFile()))
{
moduleInfoBlock.insert(&ModuleInfo());
ModuleInfo &moduleInfo=moduleInfoBlock[moduleInfoBlock.size()-1];
moduleInfo.module(moduleEntry.module());
moduleInfo.moduleBaseName(moduleEntry.strModule());
moduleInfo.moduleFileName(moduleEntry.strExePath());
}
moduleEntry.processID(processID.processID());
}
}
::CloseHandle(hSnapshot);
moduleInfoList.size(moduleInfoBlock.size());
for(int index=0;index<moduleInfoBlock.size();index++)moduleInfoList[index]=moduleInfoBlock[index];
return moduleInfoList.size()?true:false;
}

55
psapint/psapi95.hpp Normal file
View File

@@ -0,0 +1,55 @@
#ifndef _PSAPINT_PSAPI95_HPP_
#define _PSAPINT_PSAPI95_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_STRING_HPP_
#include <common/string.hpp>
#endif
#ifndef _COMMON_LIBRARY_HPP_
#include <common/library.hpp>
#endif
#ifndef _COMMON_TOOLHELP32_HPP_
#include <common/tlhelp32.hpp>
#endif
#ifndef _PSAPINT_PROCESSID_HPP_
#include <psapint/procid.hpp>
#endif
#ifndef _PSAPINT_PROCINFO_HPP_
#include <psapint/procinfo.hpp>
#endif
class ProcessEntry;
class ProcessAPI95
{
public:
ProcessAPI95(void);
virtual ~ProcessAPI95();
bool enumProcesses(ProcessInfoList &processInfoList);
bool isOkay(void)const;
private:
typedef BOOL (WINAPI *PFNPROCESS32FIRST)(HANDLE hSnapshot,PROCESSENTRY32 *lppe);
typedef BOOL (WINAPI *PFNPROCESS32NEXT)(HANDLE hSnapshot,PROCESSENTRY32 *lppe);
typedef BOOL (WINAPI *PFNMODULE32FIRST)(HANDLE hSnapshot,MODULEENTRY32 *lpme);
typedef BOOL (WINAPI *PFNMODULE32NEXT)(HANDLE hSnapshot,MODULEENTRY32 *lpme);
typedef HANDLE (WINAPI *PFNCREATETOOLHELP32SNAPSHOT)(DWORD dwFlags,DWORD thProcessID);
ProcessAPI95(const ProcessAPI95 &someProcessAPI);
ProcessAPI95 &operator=(const ProcessAPI95 &someProcessAPI);
bool enumProcessModules(const ProcessID &processID,ProcessEntry &processEntry,ModuleInfoList &moduleInfoList);
PFNPROCESS32FIRST mpfnProcess32First;
PFNPROCESS32NEXT mpfnProcess32Next;
PFNMODULE32FIRST mpfnModule32First;
PFNMODULE32NEXT mpfnModule32Next;
PFNCREATETOOLHELP32SNAPSHOT mpfnCreateToolhelp32Snapshot;
Library mLibrary;
};
inline
bool ProcessAPI95::isOkay(void)const
{
if(!mpfnProcess32First||!mpfnProcess32Next||!mpfnModule32First||!mpfnModule32Next||!mpfnCreateToolhelp32Snapshot)return false;
return true;
}
#endif

86
psapint/psapint.001 Normal file
View File

@@ -0,0 +1,86 @@
# Microsoft Developer Studio Project File - Name="psapint" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 5.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Static Library" 0x0104
CFG=psapint - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "psapint.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "psapint.mak" CFG="psapint - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "psapint - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "psapint - Win32 Debug" (based on "Win32 (x86) Static Library")
!MESSAGE
# Begin Project
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
!IF "$(CFG)" == "psapint - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo
!ELSEIF "$(CFG)" == "psapint - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "msvcobj"
# PROP Intermediate_Dir "msvcobj"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /Zp1 /MTd /GX /Z7 /Od /I "\work" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"..\exe\psapint.lib"
!ENDIF
# Begin Target
# Name "psapint - Win32 Release"
# Name "psapint - Win32 Debug"
# Begin Source File
SOURCE=.\psapi.cpp
# End Source File
# Begin Source File
SOURCE=.\psapi95.cpp
# End Source File
# End Target
# End Project

92
psapint/psapint.dsp Normal file
View File

@@ -0,0 +1,92 @@
# Microsoft Developer Studio Project File - Name="psapint" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Static Library" 0x0104
CFG=psapint - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "psapint.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "psapint.mak" CFG="psapint - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "psapint - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "psapint - Win32 Debug" (based on "Win32 (x86) Static Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "psapint - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo
!ELSEIF "$(CFG)" == "psapint - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "msvcobj"
# PROP Intermediate_Dir "msvcobj"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /Gz /MTd /GX /Z7 /Od /I "\work" /I "\parts" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "STRICT" /D "__FLAT__" /YX /FD /c
# ADD BASE RSC /l 0x409
# ADD RSC /l 0x409
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"..\exe\psapint.lib"
!ENDIF
# Begin Target
# Name "psapint - Win32 Release"
# Name "psapint - Win32 Debug"
# Begin Source File
SOURCE=.\psapi.cpp
# End Source File
# Begin Source File
SOURCE=.\psapi95.cpp
# End Source File
# End Target
# End Project