(.Net )API Hooking: Why my implemented IEnumWbemClassObject->Next() hang at original Next - hook

Question

I want to hook native code to do some cool things:
var wql=new WqlObjectQuery(queryString);
using(var searcher =new ManagementObjectSearcher(scope,wql))
{
using(var records=searcher.Get())
{
**foreach(var record in records)** //This is where I want to hook
{
//do something
}
}
}
By digging into https://referencesource.microsoft.com/ , I find .Net send WQL string to WMINet_Util.dll ExecQueryWmi() . By using MS-Detours , I succeed in outputing passed-in WQL.
To control the enumeration , I implemented my IEnumWbemClassObject & IWbemClassObject.
When ExecQueryWmi() is called , I redirect the pointer to pointer to refer to my IEnumWbemClassObject .
In implementation of IEnumWbemClassObject::Next , I also edirect the pointer to pointer to refer to my IWbemClassObject.
But the reality is ,my implemented IEnumWbemClassObject->Next() hang at original Next() , it never go to next line
I can't figure out why . Could anyone help ?
Below is my code ******************************
// dllmain.cpp : Defines the entry point for the DLL application.
#include "stdafx.h"
#include <stdio.h>
#include <strsafe.h>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <mutex>>
#include<fstream>
#include <Windows.h>
#include <comdef.h>
#include <WbemIdl.h>
#include <comdef.h>
#include <comutil.h>
#include "detours.h"
#include "ImpIEnumWbemClassObject.h"
#pragma comment(lib, "comsuppw.lib")
using namespace std;
std::mutex g_mutex;
static bool unloaded = false;
static LONG dwSlept = 0;
#pragma region Function Pre-definition
std::string WChar2Ansi(LPCWSTR pwszSrc);
std::wstring StringToWString(const std::string& s);
void WINAPI log(string& _str);
void WINAPI log(const char* log, DWORD _size);
#pragma endregion
#pragma region WMI
//forum.exetools.com/showthread.php?t=14432
//unknowncheats.me/forum/c-and-c/244372-changing-gpu-info-using-ms-detours-3-0-a.html
typedef HRESULT(__stdcall* PWMINet_Util_ExecQueryWmi) ( BSTR strQueryLanguage,BSTR strQuery,long lFlags,IWbemContext* pCtx,IEnumWbemClassObject** ppIEnumWbemClassObject,DWORD authLevel,DWORD impLevel,IWbemServices* pCurrentNamespace,BSTR strUser,BSTR strPassword,BSTR strAuthority);
PWMINet_Util_ExecQueryWmi TrueExecQueryWmi = NULL;
HRESULT(__stdcall MyExecQueryWmi) (BSTR strQueryLanguage, BSTR strQuery, long lFlags,
IWbemContext* pCtx, IEnumWbemClassObject** ppIEnumWbemClassObject, DWORD authLevel,
DWORD impLevel, IWbemServices* pCurrentNamespace, BSTR strUser,
BSTR strPassword, BSTR strAuthority)
{
if (TrueExecQueryWmi==NULL)
{
log("NO TrueExecQueryWmi()",32);
return WBEM_E_FAILED;
}
log((string("\r\n WMI MyExecQueryWmi() is called. language =") + _com_util::ConvertBSTRToString(strQueryLanguage) + " strQuery =" + _com_util::ConvertBSTRToString(strQuery) + "\r\n").c_str(), 256);
HRESULT result=TrueExecQueryWmi(strQueryLanguage,strQuery,lFlags,pCtx,ppIEnumWbemClassObject,authLevel,impLevel,pCurrentNamespace,strUser,strPassword,strAuthority);
if (string(_com_util::ConvertBSTRToString(strQuery)).find("MSFT_PhysicalDisk")!=string::npos)
{
log("\r\MSFT_PhysicalDisk found\r\n",64);
ImpIEnumWbemClassObject* myImpIEnumWbemClassObject=new ImpIEnumWbemClassObject(*ppIEnumWbemClassObject);
(*ppIEnumWbemClassObject) = myImpIEnumWbemClassObject;
log("\r\MSFT_PhysicalDisk redirected\r\n", 64);
}
return result;
}
#pragma endregion
void split(const std::string& s,
std::vector<std::string>& sv,
const char delim = ' ') {
sv.clear();
std::istringstream iss(s);
std::string temp;
while (std::getline(iss, temp, delim)) {
sv.emplace_back(std::move(temp));
}
return;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
LONG error=0;
HMODULE hMod=NULL;
string str;
if (DetourIsHelperProcess()) {
return TRUE;
}
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
str = string("\r\nlast error when DLL_PROCESS_ATTACH starts=") + to_string(GetLastError()) + "\r\n";
log(str.c_str(), str.length());
LoadLibraryA("c:\\windows\\system32\\wbem\\fastprox.dll");
LoadLibraryA("C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319\\WMINet_Utils.dll");
DetourRestoreAfterWith();
log("simple" DETOURS_STRINGIFY(DETOURS_BITS) ".dll:"
" Starting.\n",128);
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
log("aaaaaaaaaaaaa \n",32);
//DetourAttach(&(PVOID&)TrueSleepEx, TimedSleepEx
if (GetModuleHandleA("fastprox.dll")==NULL)
{
char exe[MAX_PATH];
GetModuleFileNameA(NULL,exe,MAX_PATH);
log((string("NO fastprox.dll loaded by ")+exe).c_str(),MAX_PATH);
}
else
{
if (GetModuleHandleA("WMINet_Utils.dll") == NULL)
{
char exe[MAX_PATH];
GetModuleFileNameA(NULL, exe, MAX_PATH);
log((string("NO WMINet_Utils.dll loaded by ") + exe).c_str(), MAX_PATH);
}
else
{
TrueExecQueryWmi = (PWMINet_Util_ExecQueryWmi)DetourFindFunction("WMINet_Utils.dll", "ExecQueryWmi");
if (TrueExecQueryWmi==NULL)
{
log("NO ExecQueryWmi found in WMINet_Utils.dll",128);
}
else {
DetourAttach(&(PVOID&)TrueExecQueryWmi, (LPBYTE)MyExecQueryWmi);
}
}
//DetourAttach(&(PVOID&)TrueGetTickCount, MyTickCount);
error = DetourTransactionCommit();
log("bbbbbbbbbbbb \n",32);
if (error == NO_ERROR) {
log("simple" DETOURS_STRINGIFY(DETOURS_BITS) ".dll:"
"Detoured() Succeed.\n",128);
}
else {
string s_err = string("simple") + DETOURS_STRINGIFY(DETOURS_BITS) + ".dll Error with DetourAttach() " + std::to_string(error);
log(s_err);
}
str = string("\r\nDetour attachment is DONE. last error when DLL_PROCESS_ATTACH ends=") + to_string(GetLastError()) + "\r\n";
log(str.c_str(), str.length());
SetLastError(0);
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
log("\r\n DLL_PROCESS_DETACH is called ,reason is ",64);
if (lpReserved==NULL)
{
log("loaded unsuccessfully or reference count==0 \r\n",128);
fflush(stdout);
log("loaded unsuccessfully or reference count==0 \r\n",128);
}
else {
log("process is terminating",64);
fflush(stdout);
log("process is terminating",64);
}
if (!unloaded)
{
unloaded = true;
log("DLL_PROCESS_DETACH 1st \r\n",32);
fflush(stdout);
return TRUE;
}
{
log("DLL_PROCESS_DETACH again \r\n",32);
fflush(stdout);
return TRUE;
}
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
if (TrueExecQueryWmi!=NULL)
{
DetourDetach(&(PVOID&)TrueExecQueryWmi, (LPBYTE)MyExecQueryWmi);
}
error = DetourTransactionCommit();
log("simple" DETOURS_STRINGIFY(DETOURS_BITS) ".dll:"
" Removed SleepEx() (result=%d), slept %d ticks.\r\n", dwSlept);
fflush(stdout);
break;
}
SetLastError(0);
return TRUE;
}
void WINAPI log(string& _str)
{
log(_str.c_str(),_str.length());
}
void WINAPI log(const char* log, DWORD _size)
{
g_mutex.lock();
BOOL bErrorFlag = FALSE;
DWORD dwBytesWritten = 0;
HANDLE hfile = NULL;
ofstream fout;
ifstream fin;
fin.open(logPath);
fout.open(logPath, ios::app);
if (fin.is_open())
fout << log;
fin.close();
fout.close();
g_mutex.unlock();
}
//wstring to string
std::string WChar2Ansi(LPCWSTR pwszSrc)
{
int nLen = WideCharToMultiByte(CP_ACP,0,pwszSrc,-1,NULL,0,NULL,NULL);
if (nLen<=0)
{
log("Fail in WChar2Ansi()",32);
return std::string("");
}
char* pszDst = new char[nLen];
if (NULL==pszDst)
{
log("Fail in WChar2Ansi()", 32);
return std::string("");
}
WideCharToMultiByte(CP_ACP,0,pwszSrc,-1,pszDst,nLen,NULL,NULL);
pszDst[nLen-1] = 0;
std::string strTemp(pszDst);
delete[] pszDst;
return strTemp;
}
//string o wstring
std::wstring StringToWString(const std::string& s)
{
std::wstring wszStr;
int nLength = MultiByteToWideChar(CP_ACP, 0, s.c_str(), -1, NULL, NULL);
wszStr.resize(nLength);
LPWSTR lpwszStr = new wchar_t[nLength];
MultiByteToWideChar(CP_ACP,0,s.c_str(),-1,lpwszStr,nLength);
wszStr = lpwszStr;
delete[] lpwszStr;
return wszStr;
}
//my implemented IWbemClassObject.cpp
#include "stdafx.h"
#include <stdio.h>
#include <strsafe.h>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include<fstream>
#include <mutex>>
#include <comdef.h>
#include <comutil.h>
#include "ImpIWbemClassObject.h"
using namespace std;
std::mutex g_mutex3;
const WCHAR* logPath3 = L"D:\\practice_demos\\DetourPratice\\x64\\Debug\\logWbemClassObject.txt";
void WINAPI log3(const char* log, DWORD _size);
ImpIWbemClassObject::ImpIWbemClassObject(IWbemClassObject* _realIWbemClassObject)
{
log3("\r\n ImpIWbemClassObject->ImpIWbemClassObject() ", 128);
_pIWbemClassObject = _realIWbemClassObject;
}
ImpIWbemClassObject::~ImpIWbemClassObject()
{
log3("\r\n ~ImpIWbemClassObject() ", 128);
}
#pragma region implementation of IUnkown
ULONG ImpIWbemClassObject::AddRef()
{
log3("\r\n ImpIWbemClassObject->AddRef() ", 128);
return _pIWbemClassObject->AddRef();
}
HRESULT ImpIWbemClassObject::QueryInterface(
REFIID riid,
void** ppvObject
)
{
log3("\r\n ImpIWbemClassObject->QueryInterface() ", 128);
(*ppvObject)=this;
return 1;
}
ULONG ImpIWbemClassObject::Release()
{
log3("\r\n ImpIWbemClassObject->Rlease() ", 128);
return _pIWbemClassObject->Release();
}
#pragma endregion
#pragma region below implementation
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::GetQualifierSet(
/* [out] */ IWbemQualifierSet** ppQualSet)
{
log3("\r\n ImpIWbemClassObject->GetQualifierSet() ", 128);
return _pIWbemClassObject->GetQualifierSet(ppQualSet);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::Get(
/* [string][in] */ LPCWSTR wszName,
/* [in] */ long lFlags,
/* [unique][in][out] */ VARIANT* pVal,
/* [unique][in][out] */ CIMTYPE* pType,
/* [unique][in][out] */ long* plFlavor)
{
log3("\r\n ImpIWbemClassObject->Get() ", 128);
return _pIWbemClassObject->Get(wszName,lFlags,pVal,pType,plFlavor);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::Put(
/* [string][in] */ LPCWSTR wszName,
/* [in] */ long lFlags,
/* [in] */ VARIANT* pVal,
/* [in] */ CIMTYPE Type)
{
log3("\r\n ImpIWbemClassObject->Put() ", 128);
return _pIWbemClassObject->Put(wszName,lFlags,pVal,Type);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::Delete(
/* [string][in] */ LPCWSTR wszName)
{
log3("\r\n ImpIWbemClassObject->Delete() ", 128);
return _pIWbemClassObject->Delete(wszName);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::GetNames(
/* [string][in] */ LPCWSTR wszQualifierName,
/* [in] */ long lFlags,
/* [in] */ VARIANT* pQualifierVal,
/* [out] */ SAFEARRAY** pNames)
{
log3("\r\n ImpIWbemClassObject->GetNames() ", 128);
return _pIWbemClassObject->GetNames(wszQualifierName,lFlags,pQualifierVal,pNames);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::BeginEnumeration(
/* [in] */ long lEnumFlags)
{
log3("\r\n ImpIWbemClassObject->BeginEnumeration() ", 128);
return _pIWbemClassObject->BeginEnumeration(lEnumFlags);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::EndEnumeration()
{
log3("\r\n ImpIWbemClassObject->EndEnumeration() ", 128);
return _pIWbemClassObject->EndEnumeration();
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::GetPropertyQualifierSet(
/* [string][in] */ LPCWSTR wszProperty,
/* [out] */ IWbemQualifierSet** ppQualSet)
{
log3("\r\n ImpIWbemClassObject->GetPropertyQualifierSet() ", 128);
return _pIWbemClassObject->GetPropertyQualifierSet(wszProperty,ppQualSet);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::Clone(
/* [out] */ IWbemClassObject** ppCopy)
{
log3("\r\n ImpIWbemClassObject->Clone() ", 128);
return _pIWbemClassObject->Clone(ppCopy);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::GetObjectText(
/* [in] */ long lFlags,
/* [out] */ BSTR* pstrObjectText)
{
log3("\r\n ImpIWbemClassObject->GetObjectText() ", 128);
return _pIWbemClassObject->GetObjectText(lFlags,pstrObjectText);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::SpawnDerivedClass(
/* [in] */ long lFlags,
/* [out] */ IWbemClassObject** ppNewClass)
{
log3("\r\n ImpIWbemClassObject->SpawnDerivedClass() ", 128);
return _pIWbemClassObject->SpawnDerivedClass(lFlags, ppNewClass);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::SpawnInstance(
/* [in] */ long lFlags,
/* [out] */ IWbemClassObject** ppNewInstance)
{
log3("\r\n ImpIWbemClassObject->SpawnInstance() ", 128);
return _pIWbemClassObject->SpawnInstance(lFlags,ppNewInstance);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::CompareTo(
/* [in] */ long lFlags,
/* [in] */ IWbemClassObject* pCompareTo)
{
return _pIWbemClassObject->CompareTo(lFlags,pCompareTo);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::GetPropertyOrigin(
/* [string][in] */ LPCWSTR wszName,
/* [out] */ BSTR* pstrClassName)
{
log3("\r\n ImpIWbemClassObject->GetPropertyOrigin() ", 128);
return _pIWbemClassObject->GetPropertyOrigin(wszName,pstrClassName);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::InheritsFrom(
/* [in] */ LPCWSTR strAncestor)
{
return _pIWbemClassObject->InheritsFrom(strAncestor);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::GetMethod(
/* [string][in] */ LPCWSTR wszName,
/* [in] */ long lFlags,
/* [out] */ IWbemClassObject** ppInSignature,
/* [out] */ IWbemClassObject** ppOutSignature)
{
log3("\r\n ImpIWbemClassObject->GetMethod() ", 128);
return _pIWbemClassObject->GetMethod(wszName,lFlags,ppInSignature,ppOutSignature) ;
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::PutMethod(
/* [string][in] */ LPCWSTR wszName,
/* [in] */ long lFlags,
/* [in] */ IWbemClassObject* pInSignature,
/* [in] */ IWbemClassObject* pOutSignature)
{
return _pIWbemClassObject->PutMethod(wszName,lFlags,pInSignature,pOutSignature);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::DeleteMethod(
/* [string][in] */ LPCWSTR wszName)
{
return _pIWbemClassObject->DeleteMethod(wszName);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::BeginMethodEnumeration(
/* [in] */ long lEnumFlags)
{
log3("\r\n ImpIWbemClassObject->BeginMethodEnumeration() ", 128);
return _pIWbemClassObject->BeginMethodEnumeration(lEnumFlags);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::Next(
/* [in] */ long lFlags,
/* [unique][in][out] */ BSTR* strName,
/* [unique][in][out] */ VARIANT* pVal,
/* [unique][in][out] */ CIMTYPE* pType,
/* [unique][in][out] */ long* plFlavor)
{
log3("\r\nBefore ImpIWbemClassObject->Next\r\n",64);
HRESULT result = _pIWbemClassObject->Next(lFlags,strName,pVal,pType,plFlavor);
string propertyName = string(_com_util::ConvertBSTRToString(*strName));
if ((*pVal).vt == VT_BSTR)
{
_bstr_t bs_a(*pVal);
log3((string("\r\n ImpIWbemClassObject->Next() , propertyName = ") + propertyName + " value = " + static_cast<const char*>(bs_a) + "\r\n").c_str(), 256);
}
else
{
log3((string("\r\n ImpIWbemClassObject->Next() , propertyName = ") + propertyName).c_str() , 128);
}
log3("\r\nAfter ImpIWbemClassObject->Next\r\n", 64);
return 1;
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::NextMethod(
/* [in] */ long lFlags,
/* [unique][in][out] */ BSTR* pstrName,
/* [unique][in][out] */ IWbemClassObject** ppInSignature,
/* [unique][in][out] */ IWbemClassObject** ppOutSignature)
{
log3("\r\n ImpIWbemClassObject->NextMethod() ", 128);
return _pIWbemClassObject->NextMethod(lFlags,pstrName,ppInSignature,ppOutSignature);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::EndMethodEnumeration(void)
{
return _pIWbemClassObject->EndMethodEnumeration();
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::GetMethodQualifierSet(
/* [string][in] */ LPCWSTR wszMethod,
/* [out] */ IWbemQualifierSet** ppQualSet)
{
log3("\r\n ImpIWbemClassObject->GetMethodQualifierSet() ", 128);
return _pIWbemClassObject->GetMethodQualifierSet(wszMethod,ppQualSet);
}
HRESULT STDMETHODCALLTYPE ImpIWbemClassObject::GetMethodOrigin(
/* [string][in] */ LPCWSTR wszMethodName,
/* [out] */ BSTR* pstrClassName)
{
log3("\r\n ImpIWbemClassObject->GetMethodOrigin() ", 128);
return _pIWbemClassObject->GetMethodOrigin(wszMethodName,pstrClassName);
}
#pragma endregion
void WINAPI log3(const char* log, DWORD _size)
{
g_mutex3.lock();
BOOL bErrorFlag = FALSE;
DWORD dwBytesWritten = 0;
HANDLE hfile = NULL;
ofstream fout;
ifstream fin;
fin.open(logPath3);
fout.open(logPath3, ios::app);
if (fin.is_open())
fout << log;
fin.close();
fout.close();
g_mutex3.unlock();
}
//my implemented IEnumWbelClassObject.cpp
#include "stdafx.h"
#include <stdio.h>
#include <strsafe.h>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include<fstream>
#include <mutex>>
#include <comdef.h>
#include <comutil.h>
#include "ImpIEnumWbemClassObject.h"
#include "ImpIWbemClassObject.h"
#include <atlconv.h>
using namespace std;
std::mutex g_mutex2;
const WCHAR* logPath2 = L"D:\\practice_demos\\DetourPratice\\x64\\Debug\\logIEnum.txt";
void WINAPI log2(const char* log, DWORD _size);
ImpIEnumWbemClassObject::ImpIEnumWbemClassObject(IEnumWbemClassObject* _realIEnumWbemClassObject)
{
_pIEnumWbemClassObject = _realIEnumWbemClassObject;
}
ImpIEnumWbemClassObject::~ImpIEnumWbemClassObject()
{
log2("\r\nBefore ~ImpIEnumWbemClassObject\r\n", 64);
}
ULONG ImpIEnumWbemClassObject::AddRef()
{
log2("\r\nBefore ImpIEnumWbemClassObject::AddRef\r\n", 64);
return _pIEnumWbemClassObject->AddRef();
}
HRESULT ImpIEnumWbemClassObject::QueryInterface(
REFIID riid,
void** ppvObject
)
{
log2("\r\nBefore ImpIEnumWbemClassObject::QueryInterface\r\n", 64);
LPWSTR pwsz;
HRESULT sfiid = StringFromIID(riid, &pwsz);
if (sfiid==E_OUTOFMEMORY)
{
log2("NO memeory to contain Interface name",128);
}
char riidname[256] = "";
wcstombs(riidname, pwsz,256);
log2((string("ImpIEnumWbemClassObject::QueryInterface() ")+ riidname+"\r\n").c_str(), 256);
if (riid==IID_IUnknown)
{
(*ppvObject) = this;
return 1;
}
(*ppvObject)=this;
return 1;
}
ULONG ImpIEnumWbemClassObject::Release()
{
log2("\r\nBefore ImpIEnumWbemClassObject::Release\r\n", 64);
return _pIEnumWbemClassObject->Release();
}
HRESULT ImpIEnumWbemClassObject::Clone(
IEnumWbemClassObject** ppEnum
)
{
log2("\r\nBefore ImpIEnumWbemClassObject::Clone\r\n", 64);
return _pIEnumWbemClassObject->Clone(ppEnum);
}
HRESULT ImpIEnumWbemClassObject::Next(
long lTimeout,
ULONG uCount,
IWbemClassObject** apObjects,
ULONG* puReturned
)
{
log2("\r\nBefore ImpIEnumWbemClassObject::Next\r\n", 64);
HRESULT result= _pIEnumWbemClassObject->Next(lTimeout,uCount,apObjects,puReturned);
log2("\r\Never go here , hang !!! ImpIEnumWbemClassObject::Next is done\r\n", 64); //**It never go here**
const void* pAddress = static_cast<const void*>((*apObjects));
stringstream ss;
ss << pAddress;
log2((string("\r\n original address is ")+ss.str()+"\r\n").c_str(), 64);
ImpIWbemClassObject* impIWbemClassObject=new ImpIWbemClassObject(*apObjects);
(*apObjects) = impIWbemClassObject;
pAddress = static_cast<const void*>((*apObjects));
stringstream ss2;
ss2 << pAddress;
log2((string("\r\n updated address is ") + ss2.str() + "\r\n").c_str(), 64);
log2("\r\After ImpIEnumWbemClassObject::Next\r\n", 64);
return result;
}
HRESULT ImpIEnumWbemClassObject::NextAsync(
ULONG uCount,
IWbemObjectSink* pSink
)
{
log2("\r\nBefore ImpIEnumWbemClassObject::NextAsync\r\n", 64);
return _pIEnumWbemClassObject->NextAsync(uCount,pSink);
}
HRESULT ImpIEnumWbemClassObject::Reset()
{
return _pIEnumWbemClassObject->Reset();
}
HRESULT ImpIEnumWbemClassObject::Skip(
long lTimeout,
ULONG nCount
)
{
return _pIEnumWbemClassObject->Skip(lTimeout,nCount);
}
void WINAPI log2(const char* log, DWORD _size)
{
g_mutex2.lock();
BOOL bErrorFlag = FALSE;
DWORD dwBytesWritten = 0;
HANDLE hfile = NULL;
ofstream fout;
ifstream fin;
fin.open(logPath2);
fout.open(logPath2, ios::app);
if (fin.is_open())
fout << log;
fin.close();
fout.close();
g_mutex2.unlock();
}