5036 lines
130 KiB
C++
5036 lines
130 KiB
C++
/*++
|
|
|
|
Copyright (C) 1996-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
WBEMTEST.CPP
|
|
|
|
Abstract:
|
|
|
|
Test for WBEM
|
|
|
|
History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include <locale.h>
|
|
#include <mbstring.h>
|
|
#include <wbemidl.h>
|
|
|
|
#include <cominit.h>
|
|
|
|
#include "objedit.h"
|
|
#include "wbemntfy.h"
|
|
#include "resource.h"
|
|
#include "resrc1.h"
|
|
|
|
#include "bstring.h"
|
|
|
|
#include "wbemtest.h"
|
|
|
|
#include "initguid.h"
|
|
//#include <wbemcomn.h>
|
|
#include "notsink.h"
|
|
#include "method.h"
|
|
#include "textconv.h"
|
|
#include <string.h>
|
|
#include <tchar.h>
|
|
#include <Htmlhelp.h>
|
|
//#include <wbemerror.h>
|
|
//#include <genutils.h>
|
|
|
|
DWORD gdwAuthLevel = RPC_C_AUTHN_LEVEL_PKT;
|
|
DWORD gdwImpLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
|
|
|
|
WCHAR gNameSpace[2048] = L"";
|
|
WCHAR gPassword[1024];
|
|
WCHAR * gpPassword = NULL;
|
|
WCHAR gUser[1024] = L"";
|
|
WCHAR * gpUser = NULL;
|
|
WCHAR gAuthority[1024] = L"";
|
|
WCHAR * gpAuthority = NULL;
|
|
|
|
// These will be established at ConnectServer time and should remain valid for
|
|
// the life of the namespace and all its proxies, refreshers, etc.
|
|
BSTR gpPrincipal = NULL;
|
|
COAUTHIDENTITY* gpAuthIdentity = NULL;
|
|
|
|
WCHAR gTransport[1024] = L"";
|
|
WCHAR gLocale[1024] = L"";
|
|
long gLoginType = 0;
|
|
BOOL gbSecured = FALSE;
|
|
//BOOL gbAdvanced = FALSE;
|
|
|
|
class CCreateInstanceDlg : public CWbemDialog
|
|
{
|
|
protected:
|
|
LPWSTR m_wszClass;
|
|
long m_lMaxLen;
|
|
LONG* m_plQryFlags;
|
|
public:
|
|
CCreateInstanceDlg(HWND hParent, LPWSTR wszClass, long lMaxLen, LONG* plQryFlags)
|
|
: m_wszClass(wszClass), m_lMaxLen(lMaxLen), m_plQryFlags(plQryFlags),
|
|
CWbemDialog(IDD_CREATEINSTANCE, hParent)
|
|
{}
|
|
|
|
protected:
|
|
BOOL OnInitDialog();
|
|
BOOL Verify();
|
|
};
|
|
|
|
//#pragma warning(4270:disable)
|
|
|
|
int __cdecl CmpFunc( const void *arg1, const void *arg2 )
|
|
{
|
|
if ((arg1 == NULL) || (*(int*)arg1 == 0))
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if ((arg2 == NULL) || (*(int*)arg2 == 0))
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
VARIANT t_v1;
|
|
VariantInit(&t_v1);
|
|
VARIANT t_v2;
|
|
VariantInit(&t_v2);
|
|
int retVal = 0;
|
|
|
|
if (SUCCEEDED( (*(IWbemClassObject **)arg1)->Get(L"__RELPATH", 0, &t_v1, NULL, NULL) ))
|
|
{
|
|
if (SUCCEEDED( (*(IWbemClassObject **)arg2)->Get(L"__RELPATH", 0, &t_v2, NULL, NULL) ))
|
|
{
|
|
if ( (VT_BSTR == t_v1.vt) && (VT_BSTR == t_v2.vt) )
|
|
{
|
|
char buffA[5120];
|
|
char buffB[5120];
|
|
wcstombs( buffA, t_v1.bstrVal, 5120 );
|
|
wcstombs( buffB, t_v2.bstrVal, 5120 );
|
|
int t_i = CompareStringA(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, buffA, -1, buffB, -1 );
|
|
|
|
switch (t_i)
|
|
{
|
|
case CSTR_LESS_THAN:
|
|
{
|
|
retVal = -1;
|
|
break;
|
|
}
|
|
case CSTR_EQUAL:
|
|
{
|
|
retVal = 0;
|
|
break;
|
|
}
|
|
case CSTR_GREATER_THAN:
|
|
default:
|
|
{
|
|
retVal = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
VariantClear(&t_v2);
|
|
}
|
|
|
|
VariantClear(&t_v1);
|
|
}
|
|
|
|
return retVal;
|
|
}
|
|
|
|
UINT WINAPI GetDlgItemTextX(
|
|
HWND hDlg,
|
|
int nDlgItem,
|
|
LPWSTR pStr,
|
|
int nMaxCount
|
|
)
|
|
{
|
|
char Tmp[5120];
|
|
*Tmp = 0;
|
|
*pStr = 0;
|
|
UINT uRes = GetDlgItemTextA(hDlg, nDlgItem, Tmp, 5120);
|
|
if (uRes == 0 || strlen(Tmp) == 0)
|
|
return uRes;
|
|
if (mbstowcs(pStr, Tmp, nMaxCount) == (unsigned) nMaxCount)
|
|
*(pStr + nMaxCount - 1) = 0;
|
|
return uRes;
|
|
}
|
|
|
|
BOOL GetServerNamespace(IWbemClassObject *pObj, WCHAR *szResult, int nMaxSize);
|
|
INT_PTR GetSuperclassInfo(HWND hDlg, LPWSTR pClass, LONG lMaxBuf, LONG *plQryFlags);
|
|
INT_PTR GetClassInfo(HWND hDlg, LPWSTR pClass, LONG lMaxBuf, LONG *plQryFlags);
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
IWbemLocator *g_pLocator = 0;
|
|
IWbemConnection *g_pConnection = 0;
|
|
IWbemServices *g_pNamespace = 0;
|
|
IWbemServicesEx *g_pServicesEx=NULL;
|
|
BSTR g_strNamespace = NULL;
|
|
CAppOwner g_Owner;
|
|
CContext g_Context;
|
|
|
|
void Fatal(UINT uMsg)
|
|
{
|
|
CBasicWbemDialog::MessageBox(0, uMsg, IDS_CRITICAL_ERROR, MB_OK | MB_SYSTEMMODAL);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
BOOL RegisterEventSink();
|
|
BOOL UnregisterEventSink();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
IUnsecuredApartment* CUnsecWrap::mstatic_pApartment = NULL;
|
|
IUnsecuredApartment* CUnsecWrapEx::mstatic_pApartment = NULL;
|
|
|
|
|
|
class CMainDlg : public CWbemDialog
|
|
{
|
|
protected:
|
|
void Connect(BOOL bBind);
|
|
void ConnectButtons(BOOL b);
|
|
void OpenHelp(void);
|
|
void GetClasses();
|
|
void EditClass();
|
|
void CreateClass();
|
|
void DeleteClass();
|
|
|
|
void GetInstances();
|
|
void EditInstance();
|
|
void CreateInstance();
|
|
void DeleteInstance();
|
|
|
|
void ExecQuery();
|
|
|
|
void ExecNotificationQuery();
|
|
|
|
void ExecMethod();
|
|
void OpenNs();
|
|
void CreateRefresher();
|
|
void EditContext();
|
|
void Open();
|
|
void AddObject();
|
|
void DeleteObject();
|
|
void RenameObject();
|
|
void GetObjectSecurity();
|
|
void SetObjectSecurity();
|
|
void DoServicesExGenObject(int iOpt);
|
|
|
|
LONG Timeout();
|
|
ULONG BatchCount();
|
|
|
|
LONG m_lGenFlags; // generic flags (i.e., WBEM_FLAG_ .. used in IWbemServices methods)
|
|
LONG m_lSync; // sync, async, semisync
|
|
|
|
public:
|
|
BOOL m_fNotificationQueryResultDlg;
|
|
|
|
CMainDlg() : CWbemDialog(IDD_MAIN, (HWND)NULL)
|
|
{
|
|
m_lGenFlags = 0;
|
|
m_lSync = SEMISYNC;
|
|
m_fNotificationQueryResultDlg = FALSE;
|
|
}
|
|
~CMainDlg();
|
|
|
|
BOOL OnInitDialog();
|
|
BOOL OnCommand(WORD wNotifyCode, WORD wID);
|
|
BOOL OnOK();
|
|
};
|
|
|
|
BOOL CMainDlg::OnOK()
|
|
{
|
|
if(m_lRefCount > 0)
|
|
{
|
|
MessageBox(IDS_MUST_CLOSE_WINDOWS, IDS_ERROR, MB_OK | MB_ICONSTOP);
|
|
return FALSE;
|
|
}
|
|
|
|
return CBasicWbemDialog::OnOK();
|
|
}
|
|
|
|
long CAppOwner::Release()
|
|
{
|
|
if(CRefCountable::Release() == 0)
|
|
{
|
|
//CoUninitialize();
|
|
}
|
|
return m_lRefCount;
|
|
}
|
|
|
|
|
|
int WINAPI WinMain(
|
|
HINSTANCE hInst,
|
|
HINSTANCE hPrevInst,
|
|
PSTR szCmdLine,
|
|
int iCmdShow
|
|
)
|
|
{
|
|
mbstowcs(gNameSpace, "", 1000);
|
|
g_strNamespace = SysAllocString(gNameSpace);
|
|
|
|
setlocale(LC_ALL, "");
|
|
|
|
// OLE initialization.
|
|
// ===================
|
|
|
|
HRESULT hr = InitializeCom();
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
Fatal(IDS_OLE_INIT_FAILED);
|
|
return -1;
|
|
}
|
|
|
|
gbSecured = (strstr(szCmdLine, "/sec") != NULL);
|
|
//gbAdvanced = (strstr(szCmdLine, "/test") != NULL);
|
|
|
|
if (strstr(szCmdLine, "/setp") != NULL)
|
|
{
|
|
if (FAILED(EnableAllPrivileges(TOKEN_PROCESS)))
|
|
{
|
|
Fatal(IDS_FAIL_ENABLE_ALL_PRIV);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
hr = InitializeSecurity(NULL, -1, NULL, NULL,
|
|
RPC_C_AUTHN_LEVEL_NONE,
|
|
RPC_C_IMP_LEVEL_IMPERSONATE,
|
|
NULL, EOAC_NONE, 0);
|
|
|
|
/// // Get a session object.
|
|
/// // =======================
|
|
///
|
|
/// dwRes = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
|
|
/// IID_IWbemLocator, (LPVOID *) &g_pLocator);
|
|
///
|
|
///
|
|
/// if (dwRes != S_OK)
|
|
/// {
|
|
/// Fatal(IDS_FAILED_IWBEMLOCATOR);
|
|
/// OleUninitialize();
|
|
/// Fatal(IDS_ABNORMAL_TERMINATION);
|
|
/// return -1;
|
|
/// }
|
|
///
|
|
/// dwRes = CoCreateInstance(CLSID_WbemConnection, 0, CLSCTX_INPROC_SERVER,
|
|
/// IID_IWbemConnection, (LPVOID *) &g_pConnection);
|
|
///
|
|
///
|
|
/// if (dwRes != S_OK)
|
|
/// {
|
|
/// Fatal(IDS_FAILED_IWBEMBINDER);
|
|
/// OleUninitialize();
|
|
/// Fatal(IDS_ABNORMAL_TERMINATION);
|
|
/// return -1;
|
|
/// }
|
|
|
|
|
|
|
|
CMainDlg* pDlg = new CMainDlg;
|
|
pDlg->SetDeleteOnClose();
|
|
pDlg->SetOwner(&g_Owner);
|
|
pDlg->Create();
|
|
|
|
MSG msg;
|
|
while (GetMessage(&msg, (HWND) NULL, 0, 0))
|
|
{
|
|
if(CBasicWbemDialog::IsDialogMessage(&msg))
|
|
continue;
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
if (g_pNamespace) g_pNamespace->Release();
|
|
if (g_pServicesEx) g_pServicesEx->Release();
|
|
if (g_pLocator) g_pLocator->Release();
|
|
if (g_pConnection) g_pConnection->Release();
|
|
|
|
g_Context.Clear();
|
|
CoUninitialize();
|
|
|
|
// Terminating normally.
|
|
// =====================
|
|
|
|
return 0;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
|
|
class CErrorDlg : public CWbemDialog
|
|
{
|
|
protected:
|
|
HRESULT m_hres;
|
|
IWbemClassObject* m_pErrorObj;
|
|
|
|
public:
|
|
CErrorDlg(HWND hParent, HRESULT hres, IWbemClassObject* pErrorObj = NULL)
|
|
: CWbemDialog(IDD_ERROR,hParent), m_hres(hres), m_pErrorObj(pErrorObj)
|
|
{
|
|
if(pErrorObj) pErrorObj->AddRef();
|
|
}
|
|
~CErrorDlg()
|
|
{
|
|
if(m_pErrorObj) m_pErrorObj->Release();
|
|
}
|
|
|
|
BOOL OnInitDialog();
|
|
BOOL OnCommand(WORD wNotifyCode, WORD wID);
|
|
};
|
|
|
|
BOOL CErrorDlg::OnInitDialog()
|
|
{
|
|
CenterOnParent();
|
|
|
|
WCHAR szError[TEMP_BUF];
|
|
szError[0] = 0;
|
|
WCHAR szFacility[TEMP_BUF];
|
|
szFacility[0] = 0;
|
|
char szMsg[TEMP_BUF];
|
|
char szFormat[100];
|
|
IWbemStatusCodeText * pStatus = NULL;
|
|
|
|
SCODE sc = CoCreateInstance(CLSID_WbemStatusCodeText, 0, CLSCTX_INPROC_SERVER,
|
|
IID_IWbemStatusCodeText, (LPVOID *) &pStatus);
|
|
|
|
if(sc == S_OK)
|
|
{
|
|
BSTR bstr = 0;
|
|
sc = pStatus->GetErrorCodeText(m_hres, 0, 0, &bstr);
|
|
if(sc == S_OK)
|
|
{
|
|
wcsncpy(szError, bstr, TEMP_BUF-1);
|
|
SysFreeString(bstr);
|
|
bstr = 0;
|
|
}
|
|
sc = pStatus->GetFacilityCodeText(m_hres, 0, 0, &bstr);
|
|
if(sc == S_OK)
|
|
{
|
|
wcsncpy(szFacility, bstr, TEMP_BUF-1);
|
|
SysFreeString(bstr);
|
|
bstr = 0;
|
|
}
|
|
pStatus->Release();
|
|
}
|
|
if(wcslen(szFacility) == 0 || wcslen(szError) == 0)
|
|
{
|
|
LoadString(GetModuleHandle(NULL), ERROR_FORMAT_EX, szFormat, 99);
|
|
sprintf(szMsg, szFormat, m_hres);
|
|
}
|
|
else
|
|
{
|
|
LoadString(GetModuleHandle(NULL), ERROR_FORMAT_LONG, szFormat, 99);
|
|
sprintf(szMsg, szFormat, m_hres, szFacility, szError);
|
|
}
|
|
SetDlgItemText(IDC_MESSAGE, szMsg);
|
|
|
|
|
|
EnableWindow(GetDlgItem(IDC_SHOWOBJECT), (m_pErrorObj != NULL));
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CErrorDlg::OnCommand(WORD wNotifyCode, WORD wID)
|
|
{
|
|
// Show object is the only command out there
|
|
|
|
if(wID == IDC_SHOWOBJECT)
|
|
{
|
|
CObjectEditor Ed(m_hDlg, 0, CObjectEditor::readonly, SYNC, m_pErrorObj);
|
|
Ed.Edit();
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void FormatError(HRESULT res, HWND hParent, IWbemClassObject* pErrorObj)
|
|
{
|
|
BOOL bOwn = FALSE;
|
|
if(pErrorObj == NULL)
|
|
{
|
|
IErrorInfo* pEI;
|
|
if(GetErrorInfo(0, &pEI) == S_OK)
|
|
{
|
|
pEI->QueryInterface(IID_IWbemClassObject, (void**)&pErrorObj);
|
|
pEI->Release();
|
|
if(pErrorObj)
|
|
bOwn = TRUE;
|
|
}
|
|
}
|
|
|
|
CErrorDlg Dlg(hParent, res, pErrorObj);
|
|
Dlg.Run(NULL, true); // no disablement
|
|
if(bOwn)
|
|
pErrorObj->Release();
|
|
}
|
|
|
|
|
|
static wchar_t *g_pTargetClassBuf;
|
|
static int g_nMaxTargetClassBuf;
|
|
|
|
void SetDlgItemTextWC(HWND hDlg, int ID, WCHAR * pwc)
|
|
{
|
|
int iLen = 2*(wcslen(pwc))+1;
|
|
char * pTemp = new char[iLen];
|
|
if(pTemp == NULL)
|
|
return;
|
|
wcstombs(pTemp, pwc, iLen);
|
|
SetDlgItemText(hDlg, ID, pTemp);
|
|
delete pTemp;
|
|
}
|
|
|
|
void GetDlgItemTextWC(HWND hDlg, int ID, WCHAR * pwc,int iwcSize)
|
|
{
|
|
char * pTemp = new char[iwcSize * 2];
|
|
if(pTemp == NULL)
|
|
return;
|
|
if(GetDlgItemText(hDlg, ID, pTemp, iwcSize *2))
|
|
{
|
|
mbstowcs(pwc, pTemp, iwcSize);
|
|
}
|
|
else *pwc = 0;
|
|
|
|
delete pTemp;
|
|
}
|
|
|
|
|
|
class CConnectDlg : public CWbemDialog
|
|
{
|
|
protected:
|
|
BOOL m_bBind;
|
|
LONG m_lGenFlags; // generic WBEM_FLAG_ .. flags
|
|
LONG m_lTimeout; // used in semisync only
|
|
|
|
public:
|
|
CConnectDlg(HWND hParent, BOOL bBind, LONG lGenFlags, LONG lTimeout) : CWbemDialog((bBind) ? IDD_WBEM_BIND : IDD_WBEM_CONNECT, hParent),
|
|
m_lGenFlags(lGenFlags), m_lTimeout(lTimeout)
|
|
{ m_bBind = bBind;}
|
|
|
|
protected:
|
|
enum {CONNECT_IWBEMLOCATOR, CONNECT_IWBEMCONNECTION};
|
|
enum {INTERFACE_IWBEMSERVICES, INTERFACE_IWBEMSERVICESEX, INTERFACE_IWBEMCLASSOBJECT};
|
|
|
|
BOOL OnInitDialog();
|
|
BOOL Verify();
|
|
virtual BOOL OnSelChange(int nID);
|
|
};
|
|
|
|
BOOL CConnectDlg::OnInitDialog()
|
|
{
|
|
if (gNameSpace[0]==L'\0')
|
|
SetDlgItemTextX(IDC_NAMESPACE, L"root\\default");
|
|
else
|
|
SetDlgItemTextX(IDC_NAMESPACE, gNameSpace);
|
|
SetDlgItemTextX(IDC_USER, gUser);
|
|
SetDlgItemTextX(IDC_PASSWORD, gPassword);
|
|
SetDlgItemTextX(IDC_LOCALE, gLocale);
|
|
SetDlgItemTextX(IDC_AUTHORITY, gAuthority);
|
|
BOOL bRet = CheckRadioButton(m_hDlg, IDC_NULL, IDC_BLANK, IDC_NULL);
|
|
|
|
if (gdwImpLevel == RPC_C_IMP_LEVEL_IDENTIFY)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_IMP_IDENTIFY, IDC_IMP_DELEGATE, IDC_IMP_IDENTIFY);
|
|
}
|
|
else if (gdwImpLevel == RPC_C_IMP_LEVEL_IMPERSONATE)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_IMP_IDENTIFY, IDC_IMP_DELEGATE, IDC_IMP_IMPERSONATE);
|
|
}
|
|
else if (gdwImpLevel == RPC_C_IMP_LEVEL_DELEGATE)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_IMP_IDENTIFY, IDC_IMP_DELEGATE, IDC_IMP_DELEGATE);
|
|
}
|
|
if (gdwAuthLevel == RPC_C_AUTHN_LEVEL_NONE)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_AUTH_NONE, IDC_AUTH_PACKET_PRIVACY, IDC_AUTH_NONE);
|
|
}
|
|
else if (gdwAuthLevel == RPC_C_AUTHN_LEVEL_CONNECT)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_AUTH_NONE, IDC_AUTH_PACKET_PRIVACY, IDC_AUTH_CONNECTION);
|
|
}
|
|
else if (gdwAuthLevel == RPC_C_AUTHN_LEVEL_CALL)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_AUTH_NONE, IDC_AUTH_PACKET_PRIVACY, IDC_AUTH_CALL);
|
|
}
|
|
else if (gdwAuthLevel == RPC_C_AUTHN_LEVEL_PKT)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_AUTH_NONE, IDC_AUTH_PACKET_PRIVACY, IDC_AUTH_PACKET);
|
|
}
|
|
else if (gdwAuthLevel == RPC_C_AUTHN_LEVEL_PKT_INTEGRITY)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_AUTH_NONE, IDC_AUTH_PACKET_PRIVACY, IDC_AUTH_PACKET_INTEGRITY);
|
|
}
|
|
else if (gdwAuthLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
|
|
{
|
|
CheckRadioButton(m_hDlg, IDC_AUTH_NONE, IDC_AUTH_PACKET_PRIVACY, IDC_AUTH_PACKET_PRIVACY);
|
|
}
|
|
|
|
AddStringToCombo (IDC_CONNECTUSING, "IWbemLocator (Namespaces)", CONNECT_IWBEMLOCATOR);
|
|
|
|
#if 0
|
|
RAID 167868
|
|
Support for EX temporary removed, default IWbemLocator
|
|
AddStringToCombo (IDC_CONNECTUSING, "IWbemConnection (Namespaces, Scopes, Objects)", CONNECT_IWBEMCONNECTION);
|
|
#endif
|
|
SetComboSelection (IDC_CONNECTUSING, g_pConnection ? CONNECT_IWBEMCONNECTION : CONNECT_IWBEMLOCATOR );
|
|
SendMessage (m_hDlg, WM_COMMAND, MAKEWPARAM(IDC_CONNECTUSING, CBN_SELCHANGE), (LPARAM)GetDlgItem (IDC_CONNECTUSING));
|
|
|
|
AddStringToCombo (IDC_COMPLETION, "Synchronous", SYNC);
|
|
AddStringToCombo (IDC_COMPLETION, "Semisynchronous", SEMISYNC);
|
|
AddStringToCombo (IDC_COMPLETION, "Asynchronous", ASYNC);
|
|
SetComboSelection (IDC_COMPLETION, SYNC);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL CConnectDlg::OnSelChange(int nID)
|
|
{
|
|
int sel=(int)SendDlgItemMessage (m_hDlg, IDC_CONNECTUSING, CB_GETCURSEL, 0, 0L);
|
|
int connectusing=(int)SendDlgItemMessage (m_hDlg, IDC_CONNECTUSING, CB_GETITEMDATA, sel, 0L);
|
|
sel=(int)SendDlgItemMessage (m_hDlg, IDC_INTERFACERETURNED, CB_GETCURSEL, 0, 0L);
|
|
int interfacereturned=(int)SendDlgItemMessage (m_hDlg, IDC_INTERFACERETURNED, CB_GETITEMDATA, sel, 0L);
|
|
|
|
switch (nID)
|
|
{
|
|
case IDC_CONNECTUSING:
|
|
{
|
|
bool authority=(connectusing==CONNECT_IWBEMLOCATOR);
|
|
EnableWindow (GetDlgItem (IDC_AUTHORITY), authority);
|
|
EnableWindow (GetDlgItem (IDC_AUTHORITYLABEL), authority);
|
|
|
|
bool asynchronous=(connectusing==CONNECT_IWBEMCONNECTION);
|
|
EnableWindow (GetDlgItem (IDC_COMPLETION), asynchronous);
|
|
EnableWindow (GetDlgItem (IDC_COMPLETIONLABEL), asynchronous);
|
|
if (!asynchronous)
|
|
SetComboSelection (IDC_COMPLETION, SYNC);
|
|
|
|
SendDlgItemMessage (m_hDlg, IDC_INTERFACERETURNED, CB_RESETCONTENT, 0, 0L);
|
|
AddStringToCombo (IDC_INTERFACERETURNED, "IWbemServices", INTERFACE_IWBEMSERVICES);
|
|
|
|
#if 0
|
|
RAID 167868
|
|
Support for EX temporary removed
|
|
AddStringToCombo (IDC_INTERFACERETURNED, "IWbemServicesEx", INTERFACE_IWBEMSERVICESEX);
|
|
#endif
|
|
if (connectusing==CONNECT_IWBEMCONNECTION)
|
|
AddStringToCombo (IDC_INTERFACERETURNED, "IWbemClassObject", INTERFACE_IWBEMCLASSOBJECT);
|
|
|
|
SetComboSelection (IDC_INTERFACERETURNED, ( g_pServicesEx ? INTERFACE_IWBEMSERVICESEX : INTERFACE_IWBEMSERVICES ));
|
|
|
|
SendMessage (m_hDlg, WM_COMMAND, MAKEWPARAM(IDC_INTERFACERETURNED, CBN_SELCHANGE), (LPARAM)GetDlgItem (IDC_INTERFACERETURNED));
|
|
|
|
break;
|
|
}
|
|
|
|
case IDC_INTERFACERETURNED:
|
|
{
|
|
if (connectusing==CONNECT_IWBEMLOCATOR)
|
|
SetDlgItemText (IDC_PATHLABEL, "Namespace");
|
|
else
|
|
{
|
|
if (interfacereturned==INTERFACE_IWBEMCLASSOBJECT)
|
|
SetDlgItemText (IDC_PATHLABEL, "Object Path");
|
|
else
|
|
SetDlgItemText (IDC_PATHLABEL, "Namespace/Scope");
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CConnectDlg::Verify()
|
|
{
|
|
WCHAR NameSpace[512], User[64], Password[64], Locale[128];
|
|
WCHAR Authority[64];
|
|
User[0] = Password[0] = Locale[0] = Authority[0] = NameSpace[0] = 0;
|
|
bool bBoundToObject = false;
|
|
|
|
GetDlgItemTextX(IDC_NAMESPACE, NameSpace, 512);
|
|
GetDlgItemTextX(IDC_USER, User, 64);
|
|
GetDlgItemTextX(IDC_PASSWORD, Password, 64);
|
|
GetDlgItemTextX(IDC_AUTHORITY, Authority, 64);
|
|
GetDlgItemTextX(IDC_LOCALE, Locale, 128);
|
|
|
|
bool bTreatEmptyAsBlank = (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_BLANK));
|
|
|
|
gdwAuthLevel = RPC_C_AUTHN_LEVEL_NONE;
|
|
gdwImpLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
|
|
if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_IMP_IDENTIFY))
|
|
{
|
|
gdwImpLevel = RPC_C_IMP_LEVEL_IDENTIFY ;
|
|
}
|
|
else if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_IMP_IMPERSONATE))
|
|
{
|
|
gdwImpLevel = RPC_C_IMP_LEVEL_IMPERSONATE ;
|
|
}
|
|
else if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_IMP_DELEGATE))
|
|
{
|
|
gdwImpLevel = RPC_C_IMP_LEVEL_DELEGATE ;
|
|
}
|
|
if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_AUTH_NONE))
|
|
{
|
|
gdwAuthLevel = RPC_C_AUTHN_LEVEL_NONE;
|
|
}
|
|
else if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_AUTH_CONNECTION))
|
|
{
|
|
gdwAuthLevel = RPC_C_AUTHN_LEVEL_CONNECT;
|
|
}
|
|
else if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_AUTH_CALL))
|
|
{
|
|
gdwAuthLevel = RPC_C_AUTHN_LEVEL_CALL ;
|
|
}
|
|
else if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_AUTH_PACKET))
|
|
{
|
|
gdwAuthLevel = RPC_C_AUTHN_LEVEL_PKT ;
|
|
}
|
|
else if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_AUTH_PACKET_INTEGRITY))
|
|
{
|
|
gdwAuthLevel = RPC_C_AUTHN_LEVEL_PKT_INTEGRITY ;
|
|
}
|
|
else if (BST_CHECKED == IsDlgButtonChecked(m_hDlg, IDC_AUTH_PACKET_PRIVACY))
|
|
{
|
|
gdwAuthLevel = RPC_C_AUTHN_LEVEL_PKT_PRIVACY ;
|
|
}
|
|
|
|
if(wcslen(NameSpace) < 1)
|
|
{
|
|
MessageBox(m_hDlg, IDS_INVALID_NAMESPACE, IDS_ERROR, MB_OK | MB_ICONSTOP);
|
|
return FALSE;
|
|
}
|
|
CBString bsNamespace(NameSpace);
|
|
CBString bsLocale(Locale);
|
|
|
|
HCURSOR hWait, hSave = NULL;
|
|
|
|
CBString bsUser;
|
|
CBString bsAuthority;
|
|
CBString bsPassword;
|
|
|
|
if(wcslen(User) > 0)
|
|
bsUser = User;
|
|
|
|
if(wcslen(Password) > 0)
|
|
bsPassword = Password;
|
|
else if (bTreatEmptyAsBlank)
|
|
bsPassword = L"";
|
|
|
|
if(wcslen(Authority) > 0)
|
|
bsAuthority = Authority;
|
|
|
|
// Cleanup a preexisting principal and AuthIdentity as necessary
|
|
if ( NULL != gpPrincipal )
|
|
{
|
|
SysFreeString( gpPrincipal );
|
|
gpPrincipal = NULL;
|
|
}
|
|
|
|
if ( NULL != gpAuthIdentity )
|
|
{
|
|
WbemFreeAuthIdentity( gpAuthIdentity );
|
|
gpAuthIdentity = NULL;
|
|
}
|
|
|
|
hWait = LoadCursor(NULL, IDC_WAIT);
|
|
SCODE sRes=S_OK;
|
|
if(hWait)
|
|
hSave = SetCursor(hWait);
|
|
|
|
|
|
// Determine which connection method and interface is requested.
|
|
int cursel=(int)SendDlgItemMessage (m_hDlg, IDC_CONNECTUSING, CB_GETCURSEL, 0, 0);
|
|
int ConnectUsing=(int)SendDlgItemMessage (m_hDlg, IDC_CONNECTUSING, CB_GETITEMDATA, cursel, 0);
|
|
cursel=(int)SendDlgItemMessage (m_hDlg, IDC_INTERFACERETURNED, CB_GETCURSEL, 0, 0);
|
|
int InterfaceReturned=(int)SendDlgItemMessage (m_hDlg, IDC_INTERFACERETURNED, CB_GETITEMDATA, cursel, 0);
|
|
int sel=(int)SendDlgItemMessage (m_hDlg, IDC_COMPLETION, CB_GETCURSEL, 0, 0);
|
|
LONG lSync=(LONG)SendDlgItemMessage (m_hDlg, IDC_COMPLETION, CB_GETITEMDATA, sel, 0);
|
|
IID riid;
|
|
switch (InterfaceReturned)
|
|
{
|
|
case INTERFACE_IWBEMSERVICES:
|
|
riid = IID_IWbemServices;
|
|
break;
|
|
case INTERFACE_IWBEMSERVICESEX:
|
|
riid = IID_IWbemServicesEx;
|
|
break;
|
|
case INTERFACE_IWBEMCLASSOBJECT:
|
|
riid = IID_IWbemClassObject;
|
|
}
|
|
|
|
// Obtain a connection object of the requested type.
|
|
if (g_pLocator) g_pLocator->Release();
|
|
if (g_pConnection) g_pConnection->Release();
|
|
g_pLocator=NULL;
|
|
g_pConnection=NULL;
|
|
switch (ConnectUsing)
|
|
{
|
|
case CONNECT_IWBEMLOCATOR:
|
|
{
|
|
sRes=CoCreateInstance (CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (void **)&g_pLocator);
|
|
break;
|
|
}
|
|
|
|
case CONNECT_IWBEMCONNECTION:
|
|
{
|
|
sRes=CoCreateInstance (CLSID_WbemConnection, 0, CLSCTX_INPROC_SERVER, IID_IWbemConnection, (void **)&g_pConnection);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// Connect and obtain requested interfaces.
|
|
if (g_pNamespace) g_pNamespace->Release();
|
|
if (g_pServicesEx) g_pServicesEx->Release();
|
|
g_pNamespace=NULL;
|
|
g_pServicesEx=NULL;
|
|
IWbemClassObject *pObject=NULL;
|
|
if (g_pLocator)
|
|
{
|
|
sRes=g_pLocator->ConnectServer (bsNamespace.GetString(),
|
|
bsUser.GetString(), bsPassword.GetString(),
|
|
bsLocale.GetString(), 0, bsAuthority.GetString(), g_Context, &g_pNamespace);
|
|
|
|
if (SUCCEEDED(sRes))
|
|
{
|
|
switch (InterfaceReturned)
|
|
{
|
|
case INTERFACE_IWBEMSERVICESEX:
|
|
{
|
|
sRes=g_pNamespace->QueryInterface (IID_IWbemServicesEx, (void **)&g_pServicesEx);
|
|
break;
|
|
}
|
|
|
|
case INTERFACE_IWBEMCLASSOBJECT:
|
|
{
|
|
// This should always fail. It's here so that wbemtest can display the actual
|
|
// return code as generated by QI in such a case.
|
|
sRes=g_pNamespace->QueryInterface (IID_IWbemClassObject, (void **)&pObject);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (g_pConnection)
|
|
{
|
|
IUnknown *pUnknown=NULL;
|
|
|
|
if (lSync & ASYNC)
|
|
{
|
|
CTestNotify* pSink=new CTestNotify();
|
|
|
|
sRes=g_pConnection->OpenAsync(bsNamespace.GetString(),
|
|
bsUser.GetString(), bsPassword.GetString(),
|
|
bsLocale.GetString(), 0, g_Context,
|
|
riid, pSink);
|
|
|
|
if (SUCCEEDED(sRes))
|
|
{
|
|
pSink->WaitForSignal(INFINITE);
|
|
sRes = pSink->GetStatusCode();
|
|
if(SUCCEEDED(sRes))
|
|
{
|
|
pUnknown=pSink->GetInterface();
|
|
pSink->Release();
|
|
}
|
|
}
|
|
}
|
|
else if (lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResultEx *pResult=NULL;
|
|
|
|
sRes=g_pConnection->Open (bsNamespace.GetString(),
|
|
bsUser.GetString(), bsPassword.GetString(),
|
|
bsLocale.GetString(), 0, g_Context,
|
|
riid, NULL, &pResult);
|
|
|
|
if (SUCCEEDED(sRes))
|
|
{
|
|
SetInterfaceSecurityEx (pResult, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
|
|
LONG lStatus;
|
|
while ((sRes=pResult->GetCallStatus (WBEM_INFINITE, &lStatus))==WBEM_S_TIMEDOUT)
|
|
{
|
|
Sleep(200); // give the other threads a chance
|
|
}
|
|
|
|
if (SUCCEEDED(sRes))
|
|
{
|
|
sRes=(HRESULT)lStatus;
|
|
if (sRes==WBEM_S_NO_ERROR)
|
|
{
|
|
sRes=pResult->GetResult (0, 0, IID_IWbemServices, (void**)&pUnknown);
|
|
}
|
|
}
|
|
|
|
pResult->Release();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sRes=g_pConnection->Open (bsNamespace.GetString(),
|
|
bsUser.GetString(), bsPassword.GetString(),
|
|
bsLocale.GetString(), 0, g_Context,
|
|
riid, (void **)&pUnknown, NULL);
|
|
}
|
|
|
|
if (SUCCEEDED(sRes))
|
|
{
|
|
switch (InterfaceReturned)
|
|
{
|
|
case INTERFACE_IWBEMSERVICES:
|
|
{
|
|
sRes=pUnknown->QueryInterface (IID_IWbemServices, (void **)&g_pNamespace);
|
|
break;
|
|
}
|
|
|
|
case INTERFACE_IWBEMSERVICESEX:
|
|
{
|
|
// A-DAVCOO: We temporarily need both interfaces when an IWbemServicesEx is requested.
|
|
sRes=pUnknown->QueryInterface (IID_IWbemServices, (void **)&g_pNamespace);
|
|
if (SUCCEEDED(sRes))
|
|
sRes=pUnknown->QueryInterface (IID_IWbemServicesEx, (void **)&g_pServicesEx);
|
|
|
|
break;
|
|
}
|
|
|
|
case INTERFACE_IWBEMCLASSOBJECT:
|
|
{
|
|
sRes=pUnknown->QueryInterface (IID_IWbemClassObject, (void **)&pObject);
|
|
break;
|
|
}
|
|
}
|
|
|
|
pUnknown->Release();
|
|
pUnknown=NULL;
|
|
}
|
|
}
|
|
|
|
|
|
// If an IWbemClassObject was obtained, display the object editor.
|
|
if (pObject)
|
|
{
|
|
bBoundToObject=true;
|
|
CObjectEditor ed(m_hDlg, m_lGenFlags, CObjectEditor::foreign, lSync, pObject, m_lTimeout);
|
|
ed.Edit();
|
|
|
|
pObject->Release();
|
|
pObject=NULL;
|
|
}
|
|
|
|
|
|
if(hSave)
|
|
SetCursor(hSave);
|
|
if(SUCCEEDED(sRes))
|
|
{
|
|
if(!bBoundToObject)
|
|
wcscpy(gNameSpace, NameSpace);
|
|
wcscpy(gLocale, Locale);
|
|
wcscpy(gAuthority, Authority);
|
|
wcscpy(gUser, User);
|
|
if(wcslen(gUser) > 0)
|
|
gpUser = gUser;
|
|
else
|
|
gpUser = NULL;
|
|
wcscpy(gPassword, Password);
|
|
if(wcslen(gPassword) > 0)
|
|
gpPassword = gPassword;
|
|
else if (bTreatEmptyAsBlank)
|
|
gpPassword = L"";
|
|
else
|
|
gpPassword = NULL;
|
|
|
|
if(wcslen(gAuthority) > 0)
|
|
gpAuthority = gAuthority;
|
|
else
|
|
gpAuthority = NULL;
|
|
|
|
if (g_pNamespace)
|
|
{
|
|
SetInterfaceSecurityEx(g_pNamespace, gpAuthority, gpUser, gpPassword,
|
|
gdwAuthLevel, gdwImpLevel, EOAC_NONE, &gpAuthIdentity, &gpPrincipal );
|
|
}
|
|
|
|
if (g_pServicesEx)
|
|
{
|
|
SetInterfaceSecurityEx(g_pNamespace, gpAuthority, gpUser, gpPassword,
|
|
gdwAuthLevel, gdwImpLevel, EOAC_NONE, &gpAuthIdentity, &gpPrincipal );
|
|
}
|
|
}
|
|
|
|
if (FAILED(sRes))
|
|
{
|
|
FormatError(sRes, m_hDlg);
|
|
SetDlgItemText(IDC_PASSWORD, "");
|
|
return FALSE;
|
|
}
|
|
|
|
if(bBoundToObject)
|
|
return FALSE;
|
|
else
|
|
{
|
|
SysFreeString(g_strNamespace);
|
|
g_strNamespace = SysAllocString(bsNamespace.GetString());
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
void CMainDlg::Connect(BOOL bBind)
|
|
{
|
|
if(m_lRefCount > 0)
|
|
{
|
|
MessageBox(IDS_MUST_CLOSE_WINDOWS, IDS_ERROR, MB_OK | MB_ICONSTOP);
|
|
return;
|
|
}
|
|
|
|
CConnectDlg ConnectDlg(m_hDlg, bBind, m_lGenFlags, Timeout());
|
|
INT_PTR nRes = ConnectDlg.Run();
|
|
ConnectButtons(g_pNamespace!=NULL);
|
|
|
|
if(nRes != IDOK)
|
|
{
|
|
if(g_pNamespace == NULL)
|
|
SetDlgItemText(IDC_NAMESPACE, "");
|
|
return;
|
|
}
|
|
// If here, we succeeded.
|
|
// ======================
|
|
SetDlgItemTextWC(m_hDlg, IDC_NAMESPACE, gNameSpace);
|
|
ConnectButtons(TRUE);
|
|
}
|
|
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
void CMainDlg::OpenHelp(void)
|
|
{
|
|
|
|
TCHAR helpFile[]=TEXT("\\HELP\\WBEMTEST.CHM");
|
|
const int maxPath = MAX_PATH+sizeof(helpFile)/sizeof(TCHAR);
|
|
|
|
TCHAR sysLoc[maxPath];
|
|
const int pathLen = GetWindowsDirectory (sysLoc,MAX_PATH);
|
|
|
|
if (pathLen == 0 || pathLen >=MAX_PATH)
|
|
return;
|
|
_tcscat(sysLoc,helpFile);
|
|
|
|
HtmlHelp(m_hDlg,sysLoc,HH_DISPLAY_TOPIC,0);
|
|
}
|
|
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
|
|
|
|
|
|
LRESULT CALLBACK GetClassNameDlgProc(
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
*g_pTargetClassBuf = 0;
|
|
GetDlgItemTextX(hDlg, IDC_CLASS_NAME, g_pTargetClassBuf,
|
|
g_nMaxTargetClassBuf);
|
|
EndDialog(hDlg, IDOK);
|
|
return TRUE;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, IDCANCEL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
|
|
INT_PTR GetClassName(HWND hDlg, wchar_t *pszClassName, int nLimit)
|
|
{
|
|
g_pTargetClassBuf = pszClassName;
|
|
g_nMaxTargetClassBuf = nLimit;
|
|
|
|
INT_PTR nRes = DialogBox(GetModuleHandle(0),
|
|
MAKEINTRESOURCE(IDD_CLASS_NAME), hDlg,
|
|
(DLGPROC) GetClassNameDlgProc
|
|
);
|
|
|
|
return nRes;
|
|
}
|
|
|
|
BOOL _GetObject(HWND hDlg, LONG lGenFlags, wchar_t *pszPath, LONG lSync, IWbemClassObject*& pClass,
|
|
LONG lTimeout, bool bSuppressErrors = false)
|
|
{
|
|
CBString bsPath(pszPath);
|
|
pClass = NULL;
|
|
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if (lSync & ASYNC)
|
|
{
|
|
CHourGlass hg;
|
|
CTestNotify* pNtfy = new CTestNotify(1);
|
|
|
|
res = g_pNamespace->GetObjectAsync(bsPath.GetString(),
|
|
lGenFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, CUnsecWrap(pNtfy));
|
|
|
|
if(SUCCEEDED(res))
|
|
{
|
|
pNtfy->WaitForSignal(INFINITE);
|
|
|
|
res = pNtfy->GetStatusCode(&pErrorObj);
|
|
if(SUCCEEDED(res))
|
|
{
|
|
CFlexArray* pArray = pNtfy->GetObjectArray();
|
|
|
|
if(pArray && pArray->Size() > 0)
|
|
{
|
|
pClass = (IWbemClassObject*)pArray->GetAt(0);
|
|
if (pClass)
|
|
pClass->AddRef();
|
|
}
|
|
}
|
|
}
|
|
pNtfy->Release();
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResult* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pNamespace->GetObject(bsPath.GetString(),
|
|
lGenFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, &pClass, &pCallRes);
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(lTimeout, &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::GetObject call
|
|
if ( SUCCEEDED (res) )
|
|
{
|
|
res = pCallRes->GetResultObject(0, &pClass); // don't use timeout since object should be available
|
|
}
|
|
else
|
|
{
|
|
if(!bSuppressErrors)
|
|
FormatError(res, hDlg, pErrorObj);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
res = g_pNamespace->GetObject(bsPath.GetString(),
|
|
lGenFlags,
|
|
g_Context, &pClass, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
if(!bSuppressErrors)
|
|
FormatError(res, hDlg, pErrorObj);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL _PutClass(HWND hDlg, LONG lGenFlags, LONG lChgFlags, LONG lSync,
|
|
IWbemClassObject* pClass, LONG lTimeout)
|
|
{
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if(lSync & ASYNC)
|
|
{
|
|
CHourGlass hg;
|
|
CTestNotify* pNtfy = new CTestNotify(1);
|
|
|
|
res = g_pNamespace->PutClassAsync(pClass,
|
|
lGenFlags | lChgFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, CUnsecWrap(pNtfy));
|
|
|
|
if(SUCCEEDED(res))
|
|
{
|
|
pNtfy->WaitForSignal(INFINITE);
|
|
|
|
res = pNtfy->GetStatusCode(&pErrorObj);
|
|
}
|
|
pNtfy->Release();
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResult* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pNamespace->PutClass(pClass,
|
|
lGenFlags | lChgFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, &pCallRes);
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(lTimeout, &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::PutClass call
|
|
}
|
|
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
res = g_pNamespace->PutClass(pClass,
|
|
lGenFlags | lChgFlags,
|
|
g_Context, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, hDlg, pErrorObj);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void ShowClass(HWND hDlg, LONG lGenFlags, LPWSTR wszClass, LONG lSync,
|
|
CRefCountable* pOwner, LONG lTimeout)
|
|
{
|
|
IWbemClassObject* pClass;
|
|
if(!_GetObject(hDlg, lGenFlags, wszClass, lSync, pClass, lTimeout))
|
|
return;
|
|
|
|
DWORD dwEditMode;
|
|
if(wcschr(wszClass, L'\\') || wcschr(wszClass, L':'))
|
|
dwEditMode = CObjectEditor::foreign;
|
|
else
|
|
dwEditMode = CObjectEditor::readwrite;
|
|
|
|
CObjectEditor* ped = new CObjectEditor(hDlg, lGenFlags, dwEditMode, lSync, pClass,
|
|
lTimeout);
|
|
ped->RunDetached(pOwner);
|
|
pClass->Release();
|
|
}
|
|
|
|
void CMainDlg::EditClass()
|
|
{
|
|
wchar_t Class[2048];
|
|
*Class = 0;
|
|
|
|
INT_PTR nRes = GetClassName(m_hDlg, Class, 2048);
|
|
if (nRes == IDCANCEL || wcslen(Class) == 0)
|
|
return;
|
|
|
|
// Create the requested class; the timeout is only used if semisync
|
|
IWbemClassObject* pClass;
|
|
if (!_GetObject(m_hDlg, m_lGenFlags, Class, m_lSync, pClass, Timeout()))
|
|
return;
|
|
|
|
DWORD dwEditMode = CObjectEditor::readwrite;
|
|
|
|
// Create an object that is guarenteed to be in the local server\namespace
|
|
IWbemClassObject *pLocalObj = 0;
|
|
|
|
if (_GetObject(m_hDlg, m_lGenFlags, L"__SystemClass", m_lSync, pLocalObj, Timeout(), true))
|
|
{
|
|
|
|
// Extract the server\namespace path for the objects
|
|
WCHAR szSNS1[2048], szSNS2[2048];
|
|
GetServerNamespace(pClass, szSNS1, 2048);
|
|
GetServerNamespace(pLocalObj, szSNS2, 2048);
|
|
|
|
// Set the edit permissions based on whether the requested
|
|
// object is in the same namespace
|
|
if (_wcsicmp(szSNS1, szSNS2))
|
|
dwEditMode = CObjectEditor::foreign;
|
|
}
|
|
|
|
if (pLocalObj)
|
|
pLocalObj->Release();
|
|
|
|
CObjectEditor* ped = new CObjectEditor(m_hDlg, m_lGenFlags, dwEditMode, m_lSync,
|
|
pClass, Timeout(), BatchCount());
|
|
ped->RunDetached(this);
|
|
pClass->Release();
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
|
|
static wchar_t *g_pSupClassBuf = 0;
|
|
static int g_nMaxSupClassBuf = 0;
|
|
|
|
LRESULT CALLBACK SuperclassDlgProc(
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
*g_pSupClassBuf = 0;
|
|
GetDlgItemTextX(hDlg, IDC_SUPERCLASS, g_pSupClassBuf,
|
|
g_nMaxSupClassBuf);
|
|
EndDialog(hDlg, IDOK);
|
|
return TRUE;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, IDCANCEL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
|
|
INT_PTR GetSuperclass(HWND hDlg, wchar_t *pszClassName, int nLimit)
|
|
{
|
|
g_pSupClassBuf = pszClassName;
|
|
g_nMaxSupClassBuf = nLimit;
|
|
|
|
INT_PTR nRes = DialogBox(GetModuleHandle(0),
|
|
MAKEINTRESOURCE(IDD_SUPERCLASS), hDlg,
|
|
(DLGPROC) SuperclassDlgProc
|
|
);
|
|
|
|
return nRes;
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
BOOL PreCreateClass(HWND hDlg, LONG lGenFlags, WCHAR* Superclass, LONG lSync,
|
|
IWbemClassObject*& pNewClass, LONG lTimeout)
|
|
{
|
|
// Get the parent class, if any
|
|
// ============================
|
|
|
|
IWbemClassObject* pParentClass = 0;
|
|
if (!_GetObject(hDlg, lGenFlags, Superclass, lSync, pParentClass, lTimeout))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Create an empty child class
|
|
// ===========================
|
|
|
|
HRESULT hres = WBEM_S_NO_ERROR;
|
|
if (wcslen(Superclass) > 0)
|
|
{
|
|
hres = pParentClass->SpawnDerivedClass(0, &pNewClass);
|
|
if (hres != WBEM_S_NO_ERROR)
|
|
{
|
|
FormatError(hres, hDlg);
|
|
pParentClass->Release();
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNewClass = pParentClass;
|
|
pNewClass->AddRef();
|
|
}
|
|
|
|
pParentClass->Release();
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, hDlg);
|
|
return FALSE;
|
|
}
|
|
|
|
VARIANT v;
|
|
V_VT(&v) = VT_BSTR;
|
|
V_BSTR(&v) = SysAllocString(L"");
|
|
pNewClass->Put(L"__CLASS", 0, &v, 0);
|
|
VariantClear(&v);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL _CreateClass(HWND hDlg, LONG lGenFlags, WCHAR* Superclass, LONG lSync,
|
|
IWbemClassObject** ppClass, LONG lTimeout)
|
|
{
|
|
IWbemClassObject* pNewClass;
|
|
|
|
if (!PreCreateClass(hDlg, lGenFlags, Superclass, lSync, pNewClass, lTimeout))
|
|
return FALSE;
|
|
|
|
// Start editing
|
|
// =============
|
|
|
|
CObjectEditor ed(hDlg, lGenFlags, CObjectEditor::readwrite, lSync, pNewClass,
|
|
lTimeout);
|
|
if (ed.Edit() == IDCANCEL)
|
|
{
|
|
pNewClass->Release();
|
|
return FALSE;
|
|
}
|
|
|
|
// Finally, commit the class definition if the user
|
|
// did not hit 'cancel'.
|
|
// =================================================
|
|
|
|
BOOL bRes = _PutClass(hDlg, lGenFlags, WBEM_FLAG_CREATE_ONLY, lSync, pNewClass, lTimeout);
|
|
|
|
if (bRes && ppClass)
|
|
*ppClass = pNewClass;
|
|
else
|
|
pNewClass->Release();
|
|
|
|
return bRes;
|
|
}
|
|
|
|
void CMainDlg::CreateClass()
|
|
{
|
|
wchar_t Superclass[2048];
|
|
*Superclass = 0;
|
|
|
|
// Allow user to specify a superclass.
|
|
// ====================================
|
|
|
|
INT_PTR nRes = GetSuperclass(m_hDlg, Superclass, 2048);
|
|
if ((nRes == IDCANCEL) || (nRes == 0))
|
|
return;
|
|
|
|
IWbemClassObject* pClass = NULL;
|
|
PreCreateClass(m_hDlg, m_lGenFlags, Superclass, m_lSync, pClass, Timeout());
|
|
|
|
if(pClass == NULL)
|
|
return;
|
|
|
|
CObjectEditor* ped = new CObjectEditor(m_hDlg, m_lGenFlags, CObjectEditor::readwrite,
|
|
m_lSync, pClass, Timeout(), BatchCount());
|
|
ped->RunDetached(this);
|
|
pClass->Release();
|
|
}
|
|
|
|
void CMainDlg::DeleteClass()
|
|
{
|
|
wchar_t ClassName[2048];
|
|
*ClassName = 0;
|
|
|
|
INT_PTR nRes = GetClassName(m_hDlg, ClassName, 2048);
|
|
|
|
if (nRes == IDCANCEL || wcslen(ClassName) == 0)
|
|
return;
|
|
|
|
nRes = MessageBox(IDS_DELETING_CLASS, IDS_WARNING, MB_YESNO | MB_ICONWARNING);
|
|
if(nRes != IDYES)
|
|
return;
|
|
|
|
CBString bsClassName(ClassName);
|
|
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if(m_lSync & ASYNC)
|
|
{
|
|
CHourGlass hg;
|
|
CTestNotify* pNtfy = new CTestNotify(1);
|
|
|
|
res = g_pNamespace->DeleteClassAsync(bsClassName.GetString(),
|
|
m_lGenFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, CUnsecWrap(pNtfy));
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
pNtfy->WaitForSignal(INFINITE);
|
|
|
|
res = pNtfy->GetStatusCode(&pErrorObj);
|
|
}
|
|
pNtfy->Release();
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResult* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pNamespace->DeleteClass(bsClassName.GetString(),
|
|
m_lGenFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, &pCallRes);
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
LONG lTimeout = Timeout();
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(lTimeout, &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::DeleteClass call
|
|
}
|
|
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
res = g_pNamespace->DeleteClass(bsClassName.GetString(),
|
|
m_lGenFlags,
|
|
g_Context, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, m_hDlg, pErrorObj);
|
|
return;
|
|
}
|
|
}
|
|
|
|
BOOL _PutInstance(HWND hDlg, LONG lGenFlags, LONG lChgFlags, LONG lSync,
|
|
IWbemClassObject* pInstance, LONG lTimeout)
|
|
{
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if(lSync & ASYNC)
|
|
{
|
|
CHourGlass hg;
|
|
CTestNotify* pNtfy = new CTestNotify(1);
|
|
|
|
res = g_pNamespace->PutInstanceAsync(pInstance,
|
|
lGenFlags | lChgFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, CUnsecWrap(pNtfy));
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
pNtfy->WaitForSignal(INFINITE);
|
|
|
|
res = pNtfy->GetStatusCode(&pErrorObj);
|
|
}
|
|
pNtfy->Release();
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResult* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pNamespace->PutInstance(pInstance,
|
|
lGenFlags | lChgFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, &pCallRes);
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(lTimeout, &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::PutInstance call
|
|
}
|
|
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
res = g_pNamespace->PutInstance(pInstance,
|
|
lGenFlags | lChgFlags,
|
|
g_Context, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, hDlg, pErrorObj);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
IWbemClassObject* PreCreateInstance(HWND hDlg, LONG lGenFlags, LONG lSync, LONG lTimeout)
|
|
{
|
|
// Get the class.
|
|
// ==============
|
|
wchar_t ClassName[2048];
|
|
*ClassName = 0;
|
|
|
|
long lFlags = 0;
|
|
CCreateInstanceDlg InfoDlg(hDlg, ClassName, 2048, &lFlags);
|
|
INT_PTR nRes = InfoDlg.Run();
|
|
|
|
if (nRes == IDCANCEL || wcslen(ClassName) == 0)
|
|
return NULL;
|
|
|
|
IWbemClassObject* pInst = 0;
|
|
if(lFlags == 1)
|
|
{
|
|
IWbemClassObject* pClass = 0;
|
|
if (!_GetObject(hDlg, lGenFlags, ClassName, lSync, pClass, lTimeout))
|
|
return NULL;
|
|
|
|
// Get a clean instance of the class.
|
|
// ==================================
|
|
|
|
HRESULT hres = pClass->SpawnInstance(0, &pInst);
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, hDlg);
|
|
return NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!_GetObject(hDlg, WBEM_FLAG_SPAWN_INSTANCE, ClassName, lSync, pInst, lTimeout))
|
|
return NULL;
|
|
}
|
|
|
|
return pInst;
|
|
}
|
|
|
|
IWbemClassObject* _CreateInstance(HWND hDlg, LONG lGenFlags, LONG lSync, LONG lTimeout)
|
|
{
|
|
IWbemClassObject* pInst = PreCreateInstance(hDlg, lGenFlags, lSync, lTimeout);
|
|
if(pInst == NULL)
|
|
return NULL;
|
|
|
|
// If here, we have an instance we can edit.
|
|
// =========================================
|
|
|
|
CObjectEditor ed(hDlg, lGenFlags, CObjectEditor::readwrite, lSync, pInst, lTimeout);
|
|
if (ed.Edit() == IDCANCEL)
|
|
{
|
|
pInst->Release();
|
|
return NULL;
|
|
}
|
|
|
|
return pInst;
|
|
}
|
|
|
|
|
|
void CMainDlg::CreateInstance()
|
|
{
|
|
IWbemClassObject* pInst = PreCreateInstance(m_hDlg, m_lGenFlags, m_lSync, Timeout());
|
|
if(pInst == NULL)
|
|
return;
|
|
|
|
CObjectEditor* ped = new CObjectEditor(m_hDlg, m_lGenFlags, CObjectEditor::readwrite,
|
|
m_lSync, pInst, Timeout(), BatchCount());
|
|
ped->RunDetached(this);
|
|
pInst->Release();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Refresher Object Path Dialog
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
static wchar_t *g_pszRefrObjectPath = 0;
|
|
static int g_nMaxRefrObjectPath = 0;
|
|
|
|
LRESULT CALLBACK RefrObjectPathDlgProc(
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
*g_pszRefrObjectPath = 0;
|
|
GetDlgItemTextX(hDlg, IDC_REFR_OBJECT_PATH, g_pszRefrObjectPath,
|
|
g_nMaxRefrObjectPath);
|
|
EndDialog(hDlg, IDOK);
|
|
return TRUE;
|
|
|
|
case IDC_ADDENUM:
|
|
*g_pszRefrObjectPath = 0;
|
|
GetDlgItemTextX(hDlg, IDC_REFR_OBJECT_PATH, g_pszRefrObjectPath,
|
|
g_nMaxRefrObjectPath);
|
|
EndDialog(hDlg, IDC_ADDENUM);
|
|
return TRUE;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, IDCANCEL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
INT_PTR GetRefrObjectPath(HWND hDlg, LPWSTR pStr, int nMax)
|
|
{
|
|
g_pszRefrObjectPath = pStr;
|
|
g_nMaxRefrObjectPath = nMax;
|
|
|
|
INT_PTR nRes = DialogBox(GetModuleHandle(0),
|
|
MAKEINTRESOURCE(IDD_REFRESHER_OBJECT_PATH), hDlg,
|
|
(DLGPROC) RefrObjectPathDlgProc
|
|
);
|
|
return nRes;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Object Path Dialog
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
static wchar_t *g_pszObjectPath = 0;
|
|
static int g_nMaxObjectPath = 0;
|
|
|
|
LRESULT CALLBACK ObjectPathDlgProc(
|
|
HWND hDlg,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
*g_pszObjectPath = 0;
|
|
GetDlgItemTextX(hDlg, IDC_OBJECT_PATH, g_pszObjectPath,
|
|
g_nMaxObjectPath);
|
|
EndDialog(hDlg, IDOK);
|
|
return TRUE;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, IDCANCEL);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
INT_PTR GetObjectPath(HWND hDlg, LPWSTR pStr, int nMax)
|
|
{
|
|
g_pszObjectPath = pStr;
|
|
g_nMaxObjectPath = nMax;
|
|
|
|
INT_PTR nRes = DialogBox(GetModuleHandle(0),
|
|
MAKEINTRESOURCE(IDD_OBJECT_PATH), hDlg,
|
|
(DLGPROC) ObjectPathDlgProc
|
|
);
|
|
return nRes;
|
|
}
|
|
|
|
BOOL GetServerNamespace(IWbemClassObject *pObj, WCHAR *szResult, int nMaxSize)
|
|
///////////////////////////////////////////////////////////////////
|
|
//
|
|
// Calls Get on the object's path property, removes the colon
|
|
// and object name which results in a string representing the
|
|
// server\namespace.
|
|
//
|
|
// Parameters: a pointer to a Class Object, a pointer to the output
|
|
// string, and the maximum size of the output string
|
|
//
|
|
// Returns : True if success.
|
|
//
|
|
///////////////////////////////////////////////////////////////////
|
|
{
|
|
VARIANT vObjNS;
|
|
VariantInit(&vObjNS);
|
|
|
|
// Get the full object path
|
|
HRESULT hRes = pObj->Get(L"__PATH", 0, &vObjNS, NULL, NULL);
|
|
if (FAILED(hRes))
|
|
return FALSE;
|
|
|
|
// Identify the colon location
|
|
int len = wcscspn(V_BSTR(&vObjNS), L":");
|
|
|
|
// Check boundary of the result string
|
|
if (len + 1 > nMaxSize)
|
|
return FALSE;
|
|
|
|
// Copy the server\namespace
|
|
wcsncpy(szResult, V_BSTR(&vObjNS), len);
|
|
szResult[len] = L'\0';
|
|
|
|
VariantClear(&vObjNS);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CMainDlg::EditInstance()
|
|
{
|
|
wchar_t ObjPath[2560];
|
|
|
|
// Get the path for the object to be created
|
|
INT_PTR iRet = GetObjectPath(m_hDlg, ObjPath, 2560);
|
|
if(iRet == IDCANCEL)
|
|
return;
|
|
|
|
if (wcslen(ObjPath) == 0)
|
|
{
|
|
MessageBox(IDS_NO_PATH, IDS_ERROR, MB_OK);
|
|
return;
|
|
}
|
|
|
|
// Create the requested object; the timeout is only used if semisync
|
|
IWbemClassObject *pInst = 0;
|
|
if (!_GetObject(m_hDlg, m_lGenFlags, ObjPath, m_lSync, pInst, Timeout()))
|
|
return;
|
|
|
|
DWORD dwEditMode = CObjectEditor::readwrite;
|
|
|
|
// Create an object that is guarenteed to be in the server\namespace
|
|
// This is used so that we can gray out the "save" buttons in the case
|
|
// where an a GetObject is passed another namespace and we dont have the
|
|
// IWbemServices pointer to it.
|
|
|
|
IWbemClassObject *pLocalObj = 0;
|
|
if (_GetObject(m_hDlg, m_lGenFlags, L"__SystemClass", m_lSync, pLocalObj,
|
|
Timeout(), true))
|
|
{
|
|
// Extract the server\namespace path for the objects
|
|
WCHAR szSNS1[2048], szSNS2[2048];
|
|
GetServerNamespace(pInst, szSNS1, 2048);
|
|
GetServerNamespace(pLocalObj, szSNS2, 2048);
|
|
|
|
// Set the edit permissions based on whether the requested
|
|
// object is in the same namespace
|
|
if(_wcsicmp(szSNS1, szSNS2))
|
|
dwEditMode = CObjectEditor::foreign;
|
|
|
|
if (pLocalObj)
|
|
pLocalObj->Release();
|
|
}
|
|
|
|
CObjectEditor* ped = new CObjectEditor(m_hDlg, m_lGenFlags, dwEditMode, m_lSync,
|
|
pInst, Timeout(), BatchCount());
|
|
ped->RunDetached(this);
|
|
pInst->Release();
|
|
}
|
|
|
|
|
|
void CMainDlg::DeleteInstance()
|
|
{
|
|
wchar_t ObjPath[2560];
|
|
*ObjPath = 0;
|
|
|
|
INT_PTR iRet = GetObjectPath(m_hDlg, ObjPath, 2560);
|
|
if (iRet == IDCANCEL)
|
|
return;
|
|
|
|
if (wcslen(ObjPath) == 0)
|
|
return;
|
|
|
|
CBString bsObjPath(ObjPath);
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if (m_lSync & ASYNC)
|
|
{
|
|
CHourGlass hg;
|
|
CTestNotify* pNtfy = new CTestNotify(1);
|
|
|
|
res = g_pNamespace->DeleteInstanceAsync(bsObjPath.GetString(),
|
|
m_lGenFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, CUnsecWrap(pNtfy));
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
pNtfy->WaitForSignal(INFINITE);
|
|
|
|
res = pNtfy->GetStatusCode(&pErrorObj);
|
|
}
|
|
pNtfy->Release();
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResult* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pNamespace->DeleteInstance(bsObjPath.GetString(),
|
|
m_lGenFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, &pCallRes);
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
LONG lTimeout = Timeout();
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(lTimeout, &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::DeleteIntance call
|
|
}
|
|
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
res = g_pNamespace->DeleteInstance(bsObjPath.GetString(), m_lGenFlags,
|
|
g_Context, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, m_hDlg, pErrorObj);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
class CNotificationQueryResultDlg : public CQueryResultDlg
|
|
{
|
|
public:
|
|
CNotificationQueryResultDlg(HWND hParent, LONG lGenFlags, LONG lQryFlags, LONG lSync )
|
|
: CQueryResultDlg(hParent, lGenFlags, lQryFlags, FALSE)
|
|
{
|
|
if ( SEMISYNC == lSync )
|
|
{
|
|
CMainDlg * pMainDlg = (CMainDlg*)GetWindowLongPtr(hParent, DWLP_USER);
|
|
pMainDlg->m_fNotificationQueryResultDlg = TRUE;
|
|
}
|
|
};
|
|
|
|
~CNotificationQueryResultDlg( )
|
|
{
|
|
if ( SEMISYNC == m_lSync )
|
|
{
|
|
CMainDlg * pMainDlg = (CMainDlg*)GetWindowLongPtr(m_hParent, DWLP_USER);
|
|
if ( NULL != pMainDlg )
|
|
{
|
|
pMainDlg->m_fNotificationQueryResultDlg = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// this means that the main dlg has been yanked away, so reset owner, because owner is GONE
|
|
m_pOwner = NULL;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
class CInstanceListDlg : public CQueryResultDlg
|
|
{
|
|
protected:
|
|
BSTR m_strClass;
|
|
|
|
BOOL CanAdd() { return !m_bReadOnly && m_lQryFlags & WBEM_FLAG_SHALLOW; }
|
|
IWbemClassObject* AddNewElement();
|
|
|
|
public:
|
|
CInstanceListDlg(HWND hParent, LONG lGenFlags, LONG lQryFlags, LPWSTR wszClass,
|
|
LONG lSync, BOOL bReadOnly, LONG lTimeout, ULONG nBatch)
|
|
: CQueryResultDlg(hParent, lGenFlags, lQryFlags), m_strClass(SysAllocString(wszClass))
|
|
{
|
|
SetReadOnly(bReadOnly);
|
|
// Pass on invocation method (sync, async..) related settings for use in this
|
|
// enumeration and by any further operations (editing/deleting/etc. of an instance).
|
|
SetCallMethod(lSync);
|
|
SetTimeout(lTimeout);
|
|
SetBatchCount(nBatch);
|
|
}
|
|
~CInstanceListDlg()
|
|
{
|
|
SysFreeString(m_strClass);
|
|
}
|
|
BOOL Initialize();
|
|
};
|
|
|
|
BOOL CInstanceListDlg::Initialize()
|
|
{
|
|
char szTitle[1024];
|
|
char szFormat[1024];
|
|
LoadString(GetModuleHandle(NULL), IDS_INSTANCES_OF, szFormat, 1024);
|
|
sprintf(szTitle, szFormat, m_strClass);
|
|
|
|
if(m_lQryFlags & WBEM_FLAG_DEEP)
|
|
{
|
|
LoadString(GetModuleHandle(NULL), IDS_RECURSIVE_PARENS, szFormat, 1024);
|
|
strcat(szTitle, szFormat);
|
|
}
|
|
|
|
SetTitle(szTitle);
|
|
|
|
// Asynchronous
|
|
if(m_lSync & ASYNC)
|
|
{
|
|
CNotSink* pHandler = new CNotSink(this); // contructor starts ref count at 1
|
|
SetNotify(pHandler);
|
|
|
|
HRESULT hres;
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->CreateInstanceEnumAsync(m_strClass,
|
|
m_lGenFlags | m_lQryFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, GetWrapper());
|
|
}
|
|
pHandler->Release();
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hParent);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
HRESULT hres;
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->CreateInstanceEnum(m_strClass,
|
|
m_lGenFlags | m_lQryFlags | WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
|
|
g_Context, &pEnum);
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hParent);
|
|
return FALSE;
|
|
}
|
|
|
|
// Create sink for use in NextAsync calls.
|
|
if (m_lSync & USE_NEXTASYNC)
|
|
{
|
|
CNotSink* pHandler = new CNotSink(this); // contructor starts ref count at 1
|
|
SetNotify(pHandler);
|
|
pHandler->Release();
|
|
}
|
|
|
|
SetInterfaceSecurityEx(pEnum, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
SetEnum(pEnum);
|
|
pEnum->Release();
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
HRESULT hres;
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->CreateInstanceEnum(m_strClass,
|
|
m_lGenFlags | m_lQryFlags | WBEM_FLAG_FORWARD_ONLY,
|
|
g_Context, &pEnum);
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hParent);
|
|
return FALSE;
|
|
}
|
|
|
|
SetInterfaceSecurityEx(pEnum, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
SetEnum(pEnum,hres);
|
|
pEnum->Release();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
IWbemClassObject* CInstanceListDlg::AddNewElement()
|
|
{
|
|
IWbemClassObject* pClass = 0;
|
|
if(!_GetObject(m_hDlg, m_lGenFlags, m_strClass, m_lSync, pClass, m_lTimeout))
|
|
return NULL;
|
|
|
|
// Get a clean instance of the class.
|
|
// ==================================
|
|
|
|
IWbemClassObject* pInst = 0;
|
|
HRESULT hres = pClass->SpawnInstance(0, &pInst);
|
|
pClass->Release();
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hDlg);
|
|
return NULL;
|
|
}
|
|
|
|
CObjectEditor ed(m_hDlg, m_lGenFlags, CObjectEditor::readwrite, m_lSync, pInst,
|
|
m_lTimeout, m_nBatch);
|
|
if (ed.Edit() == IDCANCEL)
|
|
{
|
|
pInst->Release();
|
|
return NULL;
|
|
}
|
|
|
|
if(_PutInstance(m_hDlg, m_lGenFlags, WBEM_FLAG_CREATE_ONLY, m_lSync, pInst, m_lTimeout))
|
|
return pInst;
|
|
else
|
|
{
|
|
pInst->Release();
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void ShowInstances(HWND hDlg, LONG lGenFlags, LONG lQryFlags, LPWSTR wszClass, LONG lSync,
|
|
CRefCountable* pOwner, LONG lTimeout, ULONG nBatch)
|
|
{
|
|
CInstanceListDlg* pDlg = new CInstanceListDlg(hDlg, lGenFlags, lQryFlags, wszClass, lSync,
|
|
FALSE, lTimeout, nBatch);
|
|
pDlg->RunDetached(pOwner);
|
|
}
|
|
|
|
void CMainDlg::GetInstances()
|
|
{
|
|
wchar_t ClassName[2560];
|
|
*ClassName = 0;
|
|
LONG lQryFlags = 0;
|
|
INT_PTR nRes = GetClassInfo(m_hDlg, ClassName, 2560, &lQryFlags);
|
|
if ((nRes == IDCANCEL) || (nRes == 0))
|
|
return;
|
|
|
|
CInstanceListDlg* pDlg = new CInstanceListDlg(m_hDlg, m_lGenFlags, lQryFlags, ClassName, m_lSync,
|
|
FALSE, Timeout(), BatchCount());
|
|
pDlg->RunDetached(this);
|
|
}
|
|
|
|
//********************************************************************
|
|
class CClassListDlg : public CQueryResultDlg
|
|
{
|
|
protected:
|
|
BSTR m_strParentClass;
|
|
|
|
BOOL CanAdd() { return !m_bReadOnly; /* && m_lQryFlags & WBEM_FLAG_SHALLOW; */ }
|
|
IWbemClassObject* AddNewElement();
|
|
|
|
public:
|
|
CClassListDlg(HWND hParent, LONG lGenFlags, LONG lQryFlags, LPWSTR wszParentClass, LONG lSync,
|
|
BOOL bReadOnly, LONG lTimeout, ULONG nBatch)
|
|
: CQueryResultDlg(hParent, lGenFlags, lQryFlags, TRUE, IDD_QUERY_RESULT_SORTED),
|
|
m_strParentClass(SysAllocString(wszParentClass))
|
|
{
|
|
SetReadOnly(bReadOnly);
|
|
// Pass on invocation method (sync, async..) related settings for use in this
|
|
// enumeration and by any further operations (editing/deleting/etc. of an instance).
|
|
SetCallMethod(lSync);
|
|
SetTimeout(lTimeout);
|
|
SetBatchCount(nBatch);
|
|
}
|
|
~CClassListDlg()
|
|
{
|
|
SysFreeString(m_strParentClass);
|
|
}
|
|
BOOL Initialize();
|
|
};
|
|
|
|
BOOL CClassListDlg::Initialize()
|
|
{
|
|
const TitleSize = 1000;
|
|
char szTitle[TitleSize];
|
|
char szFormat[1024];
|
|
if (m_strParentClass == NULL || wcslen(m_strParentClass) == 0)
|
|
{
|
|
LoadString(GetModuleHandle(NULL), IDS_TOP_LEVEL_CLASSES, szTitle, TitleSize);
|
|
}
|
|
else
|
|
{
|
|
LoadString(GetModuleHandle(NULL), IDS_CHILD_CLASSES_OF, szFormat, 1024);
|
|
sprintf(szTitle, szFormat, m_strParentClass);
|
|
}
|
|
szTitle[TitleSize-1] = '\0';
|
|
|
|
if (m_lQryFlags & WBEM_FLAG_DEEP)
|
|
{
|
|
LoadString(GetModuleHandle(NULL), IDS_RECURSIVE_PARENS, szFormat, 1024);
|
|
strncat(szTitle, szFormat, sizeof(szTitle) - strlen(szTitle) - 1);
|
|
}
|
|
|
|
SetTitle(szTitle);
|
|
|
|
// Asynchronous
|
|
if (m_lSync & ASYNC)
|
|
{
|
|
CHourGlass hg;
|
|
CNotSink* pHandler = new CNotSink(this);
|
|
SetNotify(pHandler);
|
|
|
|
HRESULT hres = g_pNamespace->CreateClassEnumAsync(m_strParentClass,
|
|
m_lGenFlags | m_lQryFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, GetWrapper());
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hParent);
|
|
return FALSE;
|
|
}
|
|
pHandler->Release();
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
HRESULT hres;
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->CreateClassEnum(m_strParentClass,
|
|
m_lGenFlags | m_lQryFlags | WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
|
|
g_Context, &pEnum);
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hParent);
|
|
return FALSE;
|
|
}
|
|
|
|
// Create sink for use in NextAsync calls.
|
|
if (m_lSync & USE_NEXTASYNC)
|
|
{
|
|
CNotSink* pHandler = new CNotSink(this); // contructor starts ref count at 1
|
|
SetNotify(pHandler);
|
|
pHandler->Release();
|
|
}
|
|
|
|
SetInterfaceSecurityEx(pEnum, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
SetEnum(pEnum);
|
|
pEnum->Release();
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
HRESULT hres;
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->CreateClassEnum(m_strParentClass,
|
|
m_lGenFlags | m_lQryFlags | WBEM_FLAG_FORWARD_ONLY,
|
|
g_Context, &pEnum);
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hParent);
|
|
return FALSE;
|
|
}
|
|
|
|
SetInterfaceSecurityEx(pEnum, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
SetEnum(pEnum,hres);
|
|
pEnum->Release();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
IWbemClassObject* CClassListDlg::AddNewElement()
|
|
{
|
|
IWbemClassObject* pClass;
|
|
if(_CreateClass(m_hDlg, m_lGenFlags, m_strParentClass, m_lSync, &pClass, m_lTimeout))
|
|
return pClass;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void ShowClasses(HWND hDlg, LONG lGenFlags, LONG lQryFlags, LPWSTR wszParentClass, LONG lSync,
|
|
CRefCountable* pOwner, LONG lTimeout, ULONG nBatch)
|
|
{
|
|
CClassListDlg* pDlg = new CClassListDlg(hDlg, lGenFlags, lQryFlags, wszParentClass,
|
|
lSync, FALSE, lTimeout, nBatch);
|
|
pDlg->RunDetached(pOwner);
|
|
}
|
|
|
|
|
|
void CMainDlg::GetClasses()
|
|
{
|
|
wchar_t Superclass[2048];
|
|
*Superclass = 0;
|
|
LONG lQryFlags = 0;
|
|
INT_PTR nRes = GetSuperclassInfo(m_hDlg, Superclass, 2048, &lQryFlags);
|
|
if ((nRes == IDCANCEL) || (nRes == 0))
|
|
return;
|
|
|
|
CClassListDlg* pDlg = new CClassListDlg(m_hDlg, m_lGenFlags, lQryFlags, Superclass, m_lSync,
|
|
FALSE, Timeout(), BatchCount());
|
|
pDlg->RunDetached(this);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
void CMainDlg::OpenNs()
|
|
{
|
|
wchar_t ObjPath[2560];
|
|
INT_PTR iRet = GetObjectPath(m_hDlg, ObjPath, 2560);
|
|
if(iRet == IDCANCEL)
|
|
return;
|
|
|
|
if (wcslen(ObjPath) == 0)
|
|
{
|
|
MessageBox(IDS_NO_PATH, IDS_ERROR, MB_OK);
|
|
return;
|
|
}
|
|
|
|
if (g_pNamespace == 0)
|
|
{
|
|
MessageBox(IDS_NO_INITIAL_CONNECTION, IDS_ERROR, MB_OK);
|
|
return;
|
|
}
|
|
|
|
IWbemServices* pNewNs = NULL;
|
|
CBString bsObjPath(ObjPath);
|
|
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if (m_lSync & ASYNC)
|
|
{
|
|
MessageBox(IDS_ASYNC_NOT_SUPPORTED, IDS_ERROR, MB_OK);
|
|
return;
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResult* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pNamespace->OpenNamespace(bsObjPath.GetString(),
|
|
m_lGenFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, NULL, &pCallRes);
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(Timeout(), &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::OpenNamespace call
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = pCallRes->GetResultServices(0, &pNewNs); // don't use timeout since object should be available
|
|
}
|
|
}
|
|
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
res = g_pNamespace->OpenNamespace(bsObjPath.GetString(),
|
|
m_lGenFlags,
|
|
g_Context, &pNewNs, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, m_hDlg, pErrorObj);
|
|
return;
|
|
}
|
|
|
|
g_pNamespace->Release();
|
|
pNewNs->QueryInterface(IID_IWbemServices, (void **)&g_pNamespace);
|
|
pNewNs->Release();
|
|
SetInterfaceSecurityEx(g_pNamespace, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
|
|
wcscat(gNameSpace, L"\\");
|
|
wcscat(gNameSpace, bsObjPath.GetString());
|
|
SetDlgItemTextWC(m_hDlg, IDC_NAMESPACE, gNameSpace);
|
|
|
|
SysFreeString(g_strNamespace);
|
|
g_strNamespace = SysAllocString(gNameSpace);
|
|
}
|
|
|
|
void CMainDlg::CreateRefresher()
|
|
{
|
|
CRefresherDlg* pDlg = new CRefresherDlg(m_hDlg, m_lGenFlags);
|
|
pDlg->RunDetached(NULL);
|
|
}
|
|
|
|
void CMainDlg::EditContext()
|
|
{
|
|
g_Context.Edit(m_hDlg);
|
|
}
|
|
|
|
//***************************************************************************
|
|
//
|
|
//***************************************************************************
|
|
|
|
void CenterOnScreen(HWND hDlg)
|
|
{
|
|
HWND hScreen = GetDesktopWindow();
|
|
|
|
RECT rScreen;
|
|
GetClientRect(hScreen, &rScreen);
|
|
|
|
RECT rDlg;
|
|
GetWindowRect(hDlg, &rDlg);
|
|
|
|
int nX = (rScreen.right - (rDlg.right - rDlg.left))/2;
|
|
int nY = (rScreen.bottom - (rDlg.bottom - rDlg.top))/2;
|
|
|
|
MoveWindow(hDlg, nX, nY, rDlg.right - rDlg.left,
|
|
rDlg.bottom - rDlg.top, TRUE);
|
|
}
|
|
|
|
|
|
void CMainDlg::ConnectButtons(BOOL b)
|
|
{
|
|
EnableWindow(GetDlgItem(IDC_CREATE_CLASS), b);
|
|
EnableWindow(GetDlgItem(IDC_GET_CLASS), b);
|
|
EnableWindow(GetDlgItem(IDC_GET_CLASSES), b);
|
|
EnableWindow(GetDlgItem(IDC_EDIT_CLASS), b);
|
|
EnableWindow(GetDlgItem(IDC_DELETE_CLASS), b);
|
|
|
|
EnableWindow(GetDlgItem(IDC_CREATE_INSTANCE), b);
|
|
EnableWindow(GetDlgItem(IDC_GET_INSTANCE), b);
|
|
EnableWindow(GetDlgItem(IDC_GET_INSTANCES), b);
|
|
EnableWindow(GetDlgItem(IDC_EDIT_INSTANCE), b);
|
|
EnableWindow(GetDlgItem(IDC_DELETE_INSTANCE), b);
|
|
|
|
EnableWindow(GetDlgItem(IDC_QUERY), b);
|
|
|
|
/// EnableWindow(GetDlgItem(IDC_ASYNC), TRUE);
|
|
/// EnableWindow(GetDlgItem(IDC_SYNC), TRUE);
|
|
/// EnableWindow(GetDlgItem(IDC_SEMISYNC), TRUE);
|
|
EnableWindow(GetDlgItem(IDC_ASYNC), b);
|
|
EnableWindow(GetDlgItem(IDC_SYNC), b);
|
|
EnableWindow(GetDlgItem(IDC_SEMISYNC), b);
|
|
EnableWindow(GetDlgItem(IDC_BATCH), b);
|
|
EnableWindow(GetDlgItem(IDC_TIMEOUT), b);
|
|
EnableWindow(GetDlgItem(IDC_BATCH), b && !(m_lSync & ASYNC));
|
|
EnableWindow(GetDlgItem(IDC_TIMEOUT), b && m_lSync & SEMISYNC && !(m_lSync & USE_NEXTASYNC));
|
|
EnableWindow(GetDlgItem(IDC_USE_NEXTASYNC), b && m_lSync & SEMISYNC);
|
|
|
|
EnableWindow(GetDlgItem(IDC_USE_AMENDED), b);
|
|
EnableWindow(GetDlgItem(IDC_DIRECT_READ), b);
|
|
|
|
EnableWindow(GetDlgItem(IDC_REGISTER), b);
|
|
EnableWindow(GetDlgItem(IDC_VIEW_REG), b);
|
|
EnableWindow(GetDlgItem(IDC_EVENTS), b);
|
|
EnableWindow(GetDlgItem(IDC_EXEC_METHOD), b);
|
|
EnableWindow(GetDlgItem(IDC_OPEN_NS), b);
|
|
|
|
EnableWindow(GetDlgItem(IDC_REFRESH), b);
|
|
|
|
// IWbemServicesEx
|
|
#if 0
|
|
RAID 167868
|
|
bool ex=(b && g_pServicesEx!=NULL);
|
|
EnableWindow(GetDlgItem(IDC_OPEN), ex);
|
|
EnableWindow(GetDlgItem(IDC_ADDOBJECT), ex);
|
|
EnableWindow(GetDlgItem(IDC_DELETEOBJECT), ex);
|
|
EnableWindow(GetDlgItem(IDC_RENAMEOBJECT), ex);
|
|
EnableWindow(GetDlgItem(IDC_GETOBJECTSECURITY), ex);
|
|
EnableWindow(GetDlgItem(IDC_SETOBJECTSECURITY), ex);
|
|
#endif
|
|
}
|
|
|
|
//////////////////
|
|
|
|
|
|
//////////////////
|
|
CQueryResultDlg::CQueryResultDlg(HWND hParent, LONG lGenFlags, LONG lQryFlags, BOOL fCanDelete, int tID)
|
|
: CWbemDialog(tID, hParent), m_pHandler(NULL), m_bReadOnly(FALSE), m_fDeletesAllowed(fCanDelete),
|
|
m_pEnum(NULL), m_pWrapper(NULL), m_bComplete(FALSE),
|
|
m_lGenFlags(lGenFlags), m_lQryFlags(lQryFlags),
|
|
m_lTimeout(0), m_nBatch(1),
|
|
m_partial_result(false)
|
|
{
|
|
m_szTitle = 0;
|
|
m_nReturnedMax = 0;
|
|
|
|
if (tID == IDD_QUERY_RESULT_SORTED)
|
|
{
|
|
m_bSort = TRUE;
|
|
}
|
|
else
|
|
{
|
|
m_bSort = FALSE;
|
|
}
|
|
}
|
|
|
|
void CQueryResultDlg::SetEnum(IEnumWbemClassObject* pEnum, HRESULT hres)
|
|
{
|
|
set_partial (hres==WBEM_S_PARTIAL_RESULTS);
|
|
m_pEnum = pEnum;
|
|
if(m_pEnum)
|
|
m_pEnum->AddRef();
|
|
if(m_hDlg)
|
|
{
|
|
PostUserMessage(m_hDlg, 0, 0); // starts processing of enumeration
|
|
}
|
|
}
|
|
|
|
// This function is called once (via PostMessage) and will loop until the
|
|
// synchronous enumeration is complete. It repeatedly requests batches of
|
|
// objects (without a timeout) and adds them to the list.
|
|
void CQueryResultDlg::ProcessEnum()
|
|
{
|
|
ULONG uIdx;
|
|
IWbemClassObject** aObjects = new IWbemClassObject*[m_nBatch];
|
|
|
|
for (uIdx = 0; uIdx < m_nBatch; uIdx++)
|
|
{
|
|
aObjects[uIdx] = NULL;
|
|
}
|
|
|
|
ULONG uRet = 0;
|
|
HRESULT hres;
|
|
|
|
// Do not use the timeout since the synchronous enumeration was
|
|
// started without WBEM_FLAG_RETURN_IMMEDIATELY.
|
|
while (SUCCEEDED(hres = m_pEnum->Next(WBEM_NO_WAIT, m_nBatch, aObjects, &uRet)))
|
|
{
|
|
for (uIdx = 0; uIdx < uRet; uIdx++)
|
|
{
|
|
if (aObjects[uIdx])
|
|
{
|
|
IWbemClassObject* pObj = aObjects[uIdx];
|
|
AddObject(pObj);
|
|
pObj->Release();
|
|
aObjects[uIdx] = NULL;
|
|
}
|
|
}
|
|
if (uRet)
|
|
SetNumBatchItems(uRet);
|
|
|
|
if (hres == WBEM_S_FALSE)
|
|
{
|
|
InvalidateRect(GetDlgItem(IDC_OBJECT_LIST), NULL, FALSE);
|
|
UpdateWindow(GetDlgItem(IDC_OBJECT_LIST));
|
|
break;
|
|
}
|
|
}
|
|
|
|
SetComplete(hres, NULL, NULL);
|
|
m_pEnum->Release();
|
|
m_pEnum = NULL;
|
|
|
|
delete [] aObjects;
|
|
}
|
|
|
|
// This function is called repeatedly (via PostMessage) until the
|
|
// semisync enumeration is complete. This function adds the objects
|
|
// to the list and requests another batch of objects with a timeout.
|
|
void CQueryResultDlg::ProcessEnumSemisync()
|
|
{
|
|
ULONG uIdx;
|
|
IWbemClassObject** aObjects = new IWbemClassObject*[m_nBatch];
|
|
|
|
for (uIdx = 0; uIdx < m_nBatch; uIdx++)
|
|
{
|
|
aObjects[uIdx] = NULL;
|
|
}
|
|
|
|
ULONG uRet = 0;
|
|
HRESULT hres = m_pEnum->Next(m_lTimeout, m_nBatch, aObjects, &uRet);
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
for (uIdx = 0; uIdx < uRet; uIdx++)
|
|
{
|
|
if (aObjects[uIdx])
|
|
{
|
|
IWbemClassObject* pObj = aObjects[uIdx];
|
|
AddObject(pObj);
|
|
pObj->Release();
|
|
aObjects[uIdx] = NULL;
|
|
}
|
|
}
|
|
|
|
if (uRet)
|
|
{
|
|
SetNumBatchItems(uRet);
|
|
InvalidateRect(GetDlgItem(IDC_OBJECT_LIST), NULL, FALSE);
|
|
UpdateWindow(GetDlgItem(IDC_OBJECT_LIST));
|
|
}
|
|
}
|
|
|
|
if (hres == WBEM_S_NO_ERROR || hres == WBEM_S_TIMEDOUT)
|
|
{
|
|
PostUserMessage(m_hDlg, 0, 0); // continues processing of enumeration
|
|
}
|
|
else
|
|
{
|
|
// Stop if an error or if WBEM_S_FALSE is returned.
|
|
// WBEM_S_FALSE indicates that the enumeration is complete.
|
|
SetComplete(hres, NULL, NULL);
|
|
m_pEnum->Release();
|
|
m_pEnum = NULL;
|
|
}
|
|
|
|
delete [] aObjects;
|
|
}
|
|
|
|
// This function is called repeatedly (via PostMessage) until the semisync
|
|
// enumeration using NextAsync is complete. This function simply requests
|
|
// another (or the first) batch of objects using the same sink.
|
|
void CQueryResultDlg::SemisyncNextAsync()
|
|
{
|
|
if (m_pEnum)
|
|
{
|
|
HRESULT hres = m_pEnum->NextAsync(m_nBatch, m_pHandler);
|
|
|
|
// If WBEM_S_FALSE or error then we are done with the enumerator.
|
|
// For NextAsync, SetStatus is called after every Indicate so that
|
|
// we must call SetComplete here.
|
|
if (hres != WBEM_S_NO_ERROR)
|
|
{
|
|
SetComplete(hres, NULL, NULL);
|
|
m_pEnum->Release();
|
|
m_pEnum = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CQueryResultDlg::SetNotify(CNotSink* pNotify)
|
|
{
|
|
m_pHandler = pNotify;
|
|
if (m_pHandler)
|
|
m_pHandler->AddRef();
|
|
|
|
CUnsecWrap Wrap(m_pHandler);
|
|
m_pWrapper = (IWbemObjectSink*)Wrap;
|
|
if(m_pWrapper)
|
|
m_pWrapper->AddRef();
|
|
}
|
|
|
|
CQueryResultDlg::~CQueryResultDlg()
|
|
{
|
|
if (m_szTitle)
|
|
delete [] m_szTitle;
|
|
|
|
if(m_pHandler)
|
|
{
|
|
m_pHandler->ResetViewer();
|
|
|
|
if(!m_bComplete)
|
|
{
|
|
CHourGlass hg;
|
|
g_pNamespace->CancelAsyncCall(m_pWrapper);
|
|
}
|
|
m_pHandler->Release();
|
|
}
|
|
|
|
if(m_pWrapper)
|
|
m_pWrapper->Release();
|
|
if(m_pEnum)
|
|
m_pEnum->Release();
|
|
|
|
for(int i = 0; i < m_InternalArray.Size(); i++)
|
|
{
|
|
// Check the pointer
|
|
if ( NULL != m_InternalArray[i] )
|
|
{
|
|
((IWbemClassObject*)m_InternalArray[i])->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CQueryResultDlg::SetTitle(char* szTitle)
|
|
{
|
|
m_szTitle = new char[strlen(szTitle)+2];
|
|
strcpy(m_szTitle, szTitle);
|
|
unsigned char* pc = (unsigned char*)m_szTitle;
|
|
while(*pc)
|
|
{
|
|
if(*pc < 32) *pc = 32;
|
|
pc = _mbsinc(pc);
|
|
}
|
|
|
|
if(m_hDlg)
|
|
{
|
|
SetDlgItemText(IDC_REQUEST, m_szTitle);
|
|
}
|
|
}
|
|
|
|
void CQueryResultDlg::PostObject(IWbemClassObject* pObject)
|
|
{
|
|
if(m_hDlg)
|
|
{
|
|
pObject->AddRef();
|
|
PostUserMessage(m_hDlg, 1, LPARAM(pObject));
|
|
}
|
|
else
|
|
{
|
|
AddObject(pObject);
|
|
}
|
|
}
|
|
|
|
void CQueryResultDlg::AddObject(IWbemClassObject* pObject)
|
|
{
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
|
|
if(pObject == NULL)
|
|
return;
|
|
pObject->AddRef();
|
|
m_InternalArray.Add(pObject);
|
|
|
|
WString wsText;
|
|
MakeListEntry(pObject, wsText);
|
|
long len = wsText.Length()*2+20;
|
|
char* szTemp = new char[len];
|
|
wcstombs(szTemp, LPWSTR(wsText), len);
|
|
SendMessage(hList, LB_ADDSTRING, 0, LPARAM(szTemp));
|
|
delete [] szTemp;
|
|
SetNumItems(SendMessage(hList, LB_GETCOUNT, 0, 0));
|
|
}
|
|
|
|
void CQueryResultDlg::MakeListEntry(IWbemClassObject* pObj, WString& ListEntry)
|
|
{
|
|
ListEntry = L"";
|
|
HRESULT hres;
|
|
if ( NULL != pObj )
|
|
{
|
|
VARIANT v;
|
|
VariantInit(&v);
|
|
pObj->Get(L"__GENUS", 0, &v, NULL, NULL);
|
|
|
|
if (V_I4(&v) == 1)
|
|
{
|
|
// Class def.
|
|
VariantClear(&v);
|
|
|
|
hres = pObj->Get(L"__CLASS", 0, &v, NULL, NULL);
|
|
if(SUCCEEDED(hres))
|
|
ListEntry += V_BSTR(&v);
|
|
else
|
|
ListEntry += L"Unknown class";
|
|
VariantClear(&v);
|
|
|
|
ListEntry += L"\t(";
|
|
|
|
hres = pObj->Get(L"__SUPERCLASS", 0, &v, NULL, NULL);
|
|
if (SUCCEEDED(hres) && V_VT(&v) == VT_BSTR)
|
|
ListEntry += V_BSTR(&v);
|
|
VariantClear(&v);
|
|
|
|
ListEntry += L')';
|
|
}
|
|
else
|
|
{
|
|
// Instance
|
|
VariantClear(&v);
|
|
|
|
hres = pObj->Get(L"__RELPATH", 0, &v, NULL, NULL);
|
|
if(FAILED(hres) || V_VT(&v) == VT_NULL)
|
|
{
|
|
hres = pObj->Get(L"__CLASS", 0, &v, NULL, NULL);
|
|
if(SUCCEEDED(hres))
|
|
ListEntry += V_BSTR(&v);
|
|
ListEntry += L"=<no key>";
|
|
}
|
|
else
|
|
{
|
|
ListEntry += V_BSTR(&v);
|
|
}
|
|
VariantClear(&v);
|
|
}
|
|
|
|
} // IF NULL != pObj
|
|
else
|
|
{
|
|
ListEntry = L"NULL Object";
|
|
}
|
|
|
|
}
|
|
|
|
void CQueryResultDlg::PostCount(long nCount)
|
|
{
|
|
if(m_hDlg)
|
|
{
|
|
PostUserMessage(m_hDlg, 3, LPARAM(nCount));
|
|
}
|
|
}
|
|
|
|
void CQueryResultDlg::RefreshItem(int nItem)
|
|
{
|
|
IWbemClassObject* pObj = (IWbemClassObject*)m_InternalArray.GetAt(nItem);
|
|
WString wsListEntry;
|
|
MakeListEntry(pObj, wsListEntry);
|
|
|
|
// Convert to ANSI (Win95 requires this)
|
|
char* szTemp = new char[wsListEntry.Length()*2+10];
|
|
wcstombs(szTemp, LPWSTR(wsListEntry), wsListEntry.Length()+1);
|
|
szTemp[wsListEntry.Length()] = '\0';
|
|
SendMessage(GetDlgItem(IDC_OBJECT_LIST), LB_DELETESTRING, nItem, 0);
|
|
SendMessage(GetDlgItem(IDC_OBJECT_LIST), LB_INSERTSTRING, nItem,
|
|
LPARAM(szTemp));
|
|
delete [] szTemp;
|
|
}
|
|
|
|
void CQueryResultDlg::RunDetached(CRefCountable* pOwner)
|
|
{
|
|
SetDeleteOnClose();
|
|
SetOwner(pOwner);
|
|
Create(FALSE);
|
|
if(!Initialize())
|
|
{
|
|
PostMessage(m_hDlg, WM_CLOSE, 0, 0);
|
|
}
|
|
}
|
|
|
|
void CQueryResultDlg::PostComplete(long lParam, BSTR strParam,
|
|
IWbemClassObject* pObjParam)
|
|
{
|
|
if(m_hDlg)
|
|
{
|
|
if (m_lSync & SEMISYNC)
|
|
{
|
|
// For semisync using NextAsync, SetStatus indicates the batch is
|
|
// complete so we continue with the sink and another NextAsync call.
|
|
PostUserMessage(m_hDlg, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
// For async, the final SetStatus has been called so we are done
|
|
// with the sink.
|
|
CStatus* pStatus = new CStatus(lParam, strParam, pObjParam);
|
|
PostUserMessage(m_hDlg, 2, (LPARAM)pStatus);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetComplete(lParam, strParam, pObjParam);
|
|
}
|
|
}
|
|
|
|
void CQueryResultDlg::SetComplete(HRESULT hres, BSTR strParam,
|
|
IWbemClassObject* pErrorObj)
|
|
{
|
|
if(m_bComplete)
|
|
return;
|
|
set_partial(hres==WBEM_S_PARTIAL_RESULTS);
|
|
m_bComplete = TRUE;
|
|
|
|
if(FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hDlg, pErrorObj);
|
|
PostMessage(m_hDlg, WM_CLOSE, 0, 0);
|
|
return;
|
|
}
|
|
|
|
if(m_pHandler)
|
|
{
|
|
m_pHandler->Release();
|
|
m_pHandler = NULL;
|
|
}
|
|
if(m_hDlg)
|
|
{
|
|
char szBuffer[1024]="";
|
|
LoadString(GetModuleHandle(NULL), m_partial_result==true?IDS_PARTIALRESULTS:IDS_DONE, szBuffer, 1024);
|
|
SetDlgItemText(IDC_STATUS, szBuffer);
|
|
EnableWindow(GetDlgItem(IDC_DELETE), CanDelete());
|
|
EnableWindow(GetDlgItem(IDC_ADD), CanAdd());
|
|
if (m_bSort)
|
|
{
|
|
qsort((void*)m_InternalArray.GetArrayPtr(), m_InternalArray.Size(), sizeof(void*), CmpFunc);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CQueryResultDlg::OnInitDialog()
|
|
{
|
|
CenterOnParent();
|
|
static LONG Tabs[] = { 80, 120, 170 };
|
|
int TabCount = 3;
|
|
|
|
SendMessage(GetDlgItem(IDC_OBJECT_LIST), LB_SETTABSTOPS,
|
|
(WPARAM) TabCount, (LPARAM) Tabs);
|
|
SendMessage(GetDlgItem(IDC_OBJECT_LIST), LB_SETHORIZONTALEXTENT,
|
|
10000, 0);
|
|
|
|
IWbemClassObject *pObj;
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
WString wsListEntry;
|
|
|
|
SetDlgItemText(IDC_REQUEST, m_szTitle);
|
|
if(m_bComplete)
|
|
{
|
|
char szBuffer[1024];
|
|
LoadString(GetModuleHandle(NULL), IDS_DONE, szBuffer, 1024);
|
|
SetDlgItemText(IDC_STATUS, szBuffer);
|
|
}
|
|
else
|
|
{
|
|
char szBuffer[1024];
|
|
LoadString(GetModuleHandle(NULL), IDS_IN_PROGRESS, szBuffer, 1024);
|
|
SetDlgItemText(IDC_STATUS, szBuffer);
|
|
}
|
|
|
|
EnableWindow(GetDlgItem(IDC_ADD), CanAdd());
|
|
EnableWindow(GetDlgItem(IDC_DELETE), CanDelete());
|
|
for(int i = 0; i < m_InternalArray.Size(); i++)
|
|
{
|
|
pObj = (IWbemClassObject*)m_InternalArray.GetAt(i);
|
|
MakeListEntry(pObj, wsListEntry);
|
|
|
|
// Convert to ANSI (Win95 requires this)
|
|
char* szTemp = new char[wsListEntry.Length()*2+10];
|
|
wcstombs(szTemp, LPWSTR(wsListEntry), wsListEntry.Length()+1);
|
|
SendMessage(hList, LB_ADDSTRING, 0, LPARAM(szTemp));
|
|
delete [] szTemp;
|
|
}
|
|
|
|
if(m_pEnum)
|
|
{
|
|
PostUserMessage(m_hDlg, 0, 0);
|
|
}
|
|
|
|
SetNumItems(m_InternalArray.Size());
|
|
|
|
if(m_bReadOnly)
|
|
{
|
|
EnableWindow(GetDlgItem(IDC_DELETE), FALSE);
|
|
EnableWindow(GetDlgItem(IDC_ADD), FALSE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Total number of items
|
|
void CQueryResultDlg::SetNumItems(LRESULT nNum)
|
|
{
|
|
char szBuffer[512];
|
|
char szFormat[500];
|
|
LoadString(GetModuleHandle(NULL), IDS_NUM_OBJECTS_FORMAT, szFormat, 500);
|
|
sprintf(szBuffer, szFormat, nNum);
|
|
SetWindowText(GetDlgItem(IDC_NUM_OBJECTS), szBuffer);
|
|
}
|
|
|
|
// Number returned in most recent sink Indicate or enum Next.
|
|
void CQueryResultDlg::SetNumBatchItems(ULONG nNum)
|
|
{
|
|
// Show only maximum returned batch size.
|
|
if (nNum > m_nReturnedMax)
|
|
{
|
|
char szBuffer[512];
|
|
char szFormat[500];
|
|
LoadString(GetModuleHandle(NULL), IDS_NUM_BATCH_FORMAT, szFormat, 500);
|
|
sprintf(szBuffer, szFormat, nNum);
|
|
SetWindowText(GetDlgItem(IDC_NUM_BATCH), szBuffer);
|
|
m_nReturnedMax = nNum;
|
|
}
|
|
}
|
|
|
|
BOOL CQueryResultDlg::ViewListElement(LRESULT nSel)
|
|
{
|
|
IWbemClassObject *pObj = 0;
|
|
|
|
pObj = (IWbemClassObject*)m_InternalArray.GetAt((DWORD)nSel);
|
|
|
|
if ( NULL != pObj )
|
|
{
|
|
CObjectEditor* ped = new CObjectEditor(m_hDlg, m_lGenFlags,
|
|
m_bReadOnly ? CObjectEditor::readonly : CObjectEditor::readwrite,
|
|
m_lSync, pObj, m_lTimeout, m_nBatch);
|
|
ped->RunDetached(m_pOwner);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CQueryResultDlg::OnDoubleClick(int nID)
|
|
{
|
|
if(nID != IDC_OBJECT_LIST) return FALSE;
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
|
|
LRESULT nSel = SendMessage(hList, LB_GETCURSEL, 0, 0);
|
|
|
|
if (nSel == LB_ERR)
|
|
return TRUE;
|
|
|
|
ViewListElement(nSel);
|
|
SendMessage(hList, LB_SETCURSEL, nSel, 0);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CQueryResultDlg::OnUser(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if(wParam == 0)
|
|
{
|
|
if (m_lSync & SEMISYNC)
|
|
{
|
|
if (m_lSync & USE_NEXTASYNC)
|
|
SemisyncNextAsync();
|
|
else
|
|
ProcessEnumSemisync();
|
|
}
|
|
else // synchronous
|
|
{
|
|
ProcessEnum();
|
|
}
|
|
return TRUE;
|
|
}
|
|
else if(wParam == 1)
|
|
{
|
|
IWbemClassObject* pObj = (IWbemClassObject*)lParam;
|
|
AddObject(pObj);
|
|
pObj->Release();
|
|
return TRUE;
|
|
}
|
|
else if(wParam == 2)
|
|
{
|
|
CStatus* pStatus = (CStatus*)lParam;
|
|
SetComplete(pStatus->m_hres, pStatus->m_str, pStatus->m_pObj);
|
|
delete pStatus;
|
|
return TRUE;
|
|
}
|
|
else if(wParam == 3)
|
|
{
|
|
SetNumBatchItems(ULONG(lParam));
|
|
return TRUE;
|
|
}
|
|
else return FALSE;
|
|
}
|
|
|
|
BOOL CQueryResultDlg::OnCommand(WORD wCode, WORD nID)
|
|
{
|
|
if(wCode == 0xFFFF && nID == 0xFFFF)
|
|
{
|
|
if (m_lSync & SEMISYNC)
|
|
{
|
|
if (m_lSync & USE_NEXTASYNC)
|
|
SemisyncNextAsync();
|
|
else
|
|
ProcessEnumSemisync();
|
|
}
|
|
else // synchronous
|
|
{
|
|
ProcessEnum();
|
|
}
|
|
return TRUE;
|
|
}
|
|
else if(nID == IDC_DELETE)
|
|
{
|
|
OnDelete();
|
|
return TRUE;
|
|
}
|
|
else if(nID == IDC_ADD)
|
|
{
|
|
OnAdd();
|
|
return TRUE;
|
|
}
|
|
else if(nID == IDC_COPY_SEL)
|
|
{
|
|
OnCopy();
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void CQueryResultDlg::OnDelete()
|
|
{
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
LRESULT nSel = SendMessage(hList, LB_GETCURSEL, 0, 0);
|
|
if (nSel == LB_ERR)
|
|
return;
|
|
|
|
if(DeleteListElement(nSel))
|
|
{
|
|
SendMessage(hList, LB_DELETESTRING, nSel, 0);
|
|
|
|
SetNumItems(SendMessage(hList, LB_GETCOUNT, 0, 0));
|
|
|
|
IWbemClassObject* pObj = (IWbemClassObject*)m_InternalArray.GetAt((DWORD)nSel);
|
|
m_InternalArray.RemoveAt((DWORD)nSel);
|
|
|
|
// Verify the pointer
|
|
if ( NULL != pObj )
|
|
{
|
|
pObj->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
BOOL CQueryResultDlg::DeleteListElement(LRESULT nSel)
|
|
{
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
|
|
IWbemClassObject *pObj = 0;
|
|
|
|
pObj = (IWbemClassObject*)m_InternalArray.GetAt((DWORD)nSel);
|
|
|
|
VARIANT vPath;
|
|
VariantInit(&vPath);
|
|
pObj->Get(L"__RELPATH", 0, &vPath, NULL, NULL);
|
|
|
|
VARIANT vGenus;
|
|
VariantInit(&vGenus);
|
|
pObj->Get(L"__GENUS", 0, &vGenus, NULL, NULL);
|
|
|
|
HRESULT hres;
|
|
if(V_I4(&vGenus) == WBEM_GENUS_CLASS)
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->DeleteClass(V_BSTR(&vPath), m_lGenFlags, g_Context, NULL);
|
|
}
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->DeleteInstance(V_BSTR(&vPath), m_lGenFlags, g_Context, NULL);
|
|
}
|
|
|
|
if(FAILED(hres))
|
|
{
|
|
FormatError(hres, m_hDlg);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CQueryResultDlg::OnAdd()
|
|
{
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
IWbemClassObject* pNewObj;
|
|
|
|
pNewObj = AddNewElement();
|
|
if(pNewObj)
|
|
{
|
|
// Search for the object with the same PATH
|
|
// ========================================
|
|
|
|
VARIANT vNewPath;
|
|
HRESULT hres = pNewObj->Get(L"__RELPATH", 0, &vNewPath, NULL, NULL);
|
|
if(SUCCEEDED(hres) && V_VT(&vNewPath) == VT_BSTR)
|
|
{
|
|
for(int i = 0; i < m_InternalArray.Size(); i++)
|
|
{
|
|
IWbemClassObject* pThis = (IWbemClassObject*)m_InternalArray[i];
|
|
|
|
// Check for a NULL pointer
|
|
if ( NULL != pThis )
|
|
{
|
|
VARIANT vThisPath;
|
|
hres = pThis->Get(L"__RELPATH", 0, &vThisPath, NULL, NULL);
|
|
if(SUCCEEDED(hres) && V_VT(&vThisPath) == VT_BSTR &&
|
|
!_wcsicmp(V_BSTR(&vThisPath), V_BSTR(&vNewPath)))
|
|
{
|
|
// Found a duplicate
|
|
// =================
|
|
|
|
pThis->Release();
|
|
m_InternalArray.SetAt(i, pNewObj);
|
|
RefreshItem(i);
|
|
return;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
AddObject(pNewObj);
|
|
pNewObj->Release();
|
|
|
|
if (m_bSort)
|
|
{
|
|
qsort((void*)m_InternalArray.GetArrayPtr(), m_InternalArray.Size(), sizeof(void*), CmpFunc);
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: WM_COPY doesn't work for listbox so we need to code
|
|
// OpenClipboard & SetClipboardData. Also need way to copy all
|
|
// items to clipboard. Buttons changed to invisible for now.
|
|
void CQueryResultDlg::OnCopy()
|
|
{
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
SendMessage(hList, WM_COPY, 0, 0);
|
|
}
|
|
|
|
IWbemClassObject* CQueryResultDlg::AddNewElement()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
////////////////////////////
|
|
|
|
char *CQueryDlg::m_szLastQueryType = NULL;
|
|
char *CQueryDlg::m_szLastQuery = NULL;
|
|
|
|
BOOL CQueryDlg::OnInitDialog()
|
|
{
|
|
AddStringToCombo(IDC_QUERY_TYPE, "WQL");
|
|
|
|
// Initialize Query Type
|
|
|
|
if(NULL == m_szLastQueryType)
|
|
{
|
|
m_szLastQueryType = new char[8];
|
|
strcpy(m_szLastQueryType, "WQL");
|
|
}
|
|
|
|
// Initialize Query String
|
|
|
|
if (NULL == m_szLastQuery)
|
|
{
|
|
m_szLastQuery = new char[1];
|
|
*m_szLastQuery = 0;
|
|
}
|
|
|
|
LRESULT uRes = SendMessage(GetDlgItem(IDC_QUERY_TYPE), CB_SELECTSTRING,
|
|
WPARAM(-1), LPARAM(m_szLastQueryType));
|
|
|
|
SetDlgItemText(IDC_QUERY_STRING, m_szLastQuery);
|
|
SendMessage(GetDlgItem(IDC_QUERY_STRING), EM_SETSEL, 0, -1);
|
|
EnableWindow(GetDlgItem(IDC_PROTOTYPE), NULL != m_plQryFlags);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CQueryDlg::Verify()
|
|
{
|
|
UINT uRes = 0;
|
|
UINT uStringSize = 0;
|
|
|
|
// Query String Processing
|
|
|
|
if (*m_pwszQueryString)
|
|
delete [] *m_pwszQueryString;
|
|
|
|
// Determine the required size of the buffer
|
|
uRes = GetDlgItemTextX(IDC_QUERY_STRING, *m_pwszQueryString, uStringSize);
|
|
if(0 == uRes)
|
|
{
|
|
MessageBox(IDS_MUST_SPECIFY_QUERY, IDS_ERROR,
|
|
MB_OK | MB_ICONHAND);
|
|
return FALSE;
|
|
}
|
|
|
|
// Create the buffer
|
|
uStringSize = uRes + 10;
|
|
*m_pwszQueryString = new wchar_t[uStringSize];
|
|
|
|
// Fetch the text
|
|
uRes = GetDlgItemTextX(IDC_QUERY_STRING, *m_pwszQueryString, uStringSize);
|
|
if(wcslen(*m_pwszQueryString) == 0)
|
|
{
|
|
MessageBox(IDS_MUST_SPECIFY_QUERY, IDS_ERROR,
|
|
MB_OK | MB_ICONHAND);
|
|
return FALSE;
|
|
}
|
|
|
|
// Set up last query member
|
|
if (m_szLastQuery)
|
|
delete [] m_szLastQuery;
|
|
m_szLastQuery = new char[uStringSize];
|
|
wcstombs(m_szLastQuery, *m_pwszQueryString, uStringSize);
|
|
m_szLastQuery[uStringSize - 1] = '\0';
|
|
|
|
// Query Type Processing
|
|
|
|
if (*m_pwszQueryType)
|
|
delete [] *m_pwszQueryType;
|
|
uStringSize = 0;
|
|
|
|
// Determine the required size of the buffer
|
|
uRes = GetDlgItemTextX(IDC_QUERY_TYPE, *m_pwszQueryType, uStringSize);
|
|
if(0 == uRes)
|
|
{
|
|
MessageBox(IDS_MUST_SPECIFY_QUERY_LANGUAGE, IDS_ERROR,
|
|
MB_OK | MB_ICONHAND);
|
|
return FALSE;
|
|
}
|
|
|
|
// Create the buffer
|
|
uStringSize = uRes + 10;
|
|
*m_pwszQueryType = new wchar_t[uStringSize];
|
|
|
|
// Fetch the text
|
|
uRes = GetDlgItemTextX(IDC_QUERY_TYPE, *m_pwszQueryType, uStringSize);
|
|
if(wcslen(*m_pwszQueryType) == 0)
|
|
{
|
|
MessageBox(IDS_MUST_SPECIFY_QUERY_LANGUAGE, IDS_ERROR,
|
|
MB_OK | MB_ICONHAND);
|
|
return FALSE;
|
|
}
|
|
|
|
// Set up last query type
|
|
if (m_szLastQueryType)
|
|
delete [] m_szLastQueryType;
|
|
m_szLastQueryType = new char[uStringSize];
|
|
wcstombs(m_szLastQueryType, *m_pwszQueryType, uStringSize);
|
|
m_szLastQueryType[uStringSize - 1] = '\0';
|
|
|
|
if(m_plQryFlags)
|
|
{
|
|
if(GetCheck(IDC_PROTOTYPE) == BST_CHECKED)
|
|
*m_plQryFlags |= WBEM_FLAG_PROTOTYPE;
|
|
else
|
|
*m_plQryFlags &= ~WBEM_FLAG_PROTOTYPE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// ****************************************************************************
|
|
|
|
BOOL _ExecQuery(HWND hDlg, LONG lGenFlags, LONG lQryFlags, LPWSTR wszQuery, LPWSTR wszLanguage,
|
|
LONG lSync, CQueryResultDlg* pRes, char* pWindowTitle, LONG lTimeout, ULONG nBatch)
|
|
{
|
|
CBString bsQueryType(wszLanguage);
|
|
CBString bsQueryStr(wszQuery);
|
|
|
|
if(pWindowTitle)
|
|
pRes->SetTitle(pWindowTitle);
|
|
|
|
HRESULT hres;
|
|
|
|
// Asynchronous
|
|
if(lSync & ASYNC)
|
|
{
|
|
CNotSink* pHandler = new CNotSink(pRes); // constructor starts ref count at 1
|
|
pRes->SetNotify(pHandler);
|
|
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->ExecQueryAsync(bsQueryType.GetString(), bsQueryStr.GetString(),
|
|
lGenFlags | lQryFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, pRes->GetWrapper());
|
|
}
|
|
pHandler->Release();
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, hDlg);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (lSync & SEMISYNC)
|
|
{
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->ExecQuery(bsQueryType.GetString(), bsQueryStr.GetString(),
|
|
lGenFlags | lQryFlags | WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
|
|
g_Context, &pEnum);
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, hDlg);
|
|
return FALSE;
|
|
}
|
|
|
|
// Create sink for use in NextAsync calls.
|
|
if (lSync & USE_NEXTASYNC)
|
|
{
|
|
CNotSink* pHandler = new CNotSink(pRes); // contructor starts ref count at 1
|
|
pRes->SetNotify(pHandler);
|
|
pHandler->Release();
|
|
}
|
|
|
|
SetInterfaceSecurityEx(pEnum, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
pRes->SetEnum(pEnum);
|
|
pEnum->Release();
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->ExecQuery(bsQueryType.GetString(), bsQueryStr.GetString(),
|
|
lGenFlags | lQryFlags | WBEM_FLAG_FORWARD_ONLY,
|
|
g_Context, &pEnum);
|
|
}
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, hDlg);
|
|
return FALSE;
|
|
}
|
|
|
|
SetInterfaceSecurityEx(pEnum, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
pRes->SetEnum(pEnum,hres);
|
|
pEnum->Release();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CMainDlg::ExecQuery()
|
|
{
|
|
wchar_t *pQueryStr = 0;
|
|
wchar_t *pQueryType = 0;
|
|
LONG lQryFlags = 0;
|
|
|
|
CQueryDlg QD(m_hDlg, &lQryFlags, &pQueryStr, &pQueryType);
|
|
INT_PTR nRes = QD.Run();
|
|
|
|
if ((nRes == IDCANCEL) || (nRes == 0) || (!pQueryStr) || (!pQueryType))
|
|
return;
|
|
|
|
// If here, we are ready to execute the query.
|
|
// ===========================================
|
|
|
|
CQueryResultDlg* pResDlg = new CQueryResultDlg(m_hDlg, m_lGenFlags, lQryFlags);
|
|
// Pass on invocation method (sync, async..) and related settings for this
|
|
// query and by any further operations (editing/deleting/etc. of an instance).
|
|
pResDlg->SetCallMethod(m_lSync);
|
|
pResDlg->SetTimeout(Timeout());
|
|
pResDlg->SetBatchCount(BatchCount());
|
|
|
|
wchar_t szDest[512];
|
|
szDest[511] = L'\0';
|
|
char szTitle[1000];
|
|
sprintf(szTitle, "%S: %S", pQueryType, wcsncpy(szDest, pQueryStr, 511));
|
|
|
|
if (_ExecQuery(m_hDlg, m_lGenFlags, lQryFlags, pQueryStr, pQueryType, m_lSync,
|
|
pResDlg, szTitle, Timeout(), BatchCount()))
|
|
{
|
|
pResDlg->RunDetached(this);
|
|
}
|
|
else
|
|
{
|
|
delete pResDlg;
|
|
}
|
|
|
|
delete [] pQueryStr;
|
|
delete [] pQueryType;
|
|
}
|
|
|
|
// ****************************************************************************
|
|
|
|
BOOL _ExecNotificationQuery(HWND hDlg, LONG lGenFlags, LONG lQryFlags, LPWSTR wszQuery,
|
|
LPWSTR wszLanguage, LONG lSync, CQueryResultDlg* pRes,
|
|
char* pWindowTitle, LONG lTimeout, ULONG nBatch)
|
|
{
|
|
CBString bsQueryType(wszLanguage);
|
|
CBString bsQueryStr(wszQuery);
|
|
|
|
if(pWindowTitle)
|
|
pRes->SetTitle(pWindowTitle);
|
|
|
|
HRESULT hres;
|
|
|
|
// Asynchronous
|
|
if(lSync & ASYNC)
|
|
{
|
|
CNotSink* pHandler = new CNotSink(pRes); // constructor starts ref count at 1
|
|
pRes->SetNotify(pHandler);
|
|
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->ExecNotificationQueryAsync(bsQueryType.GetString(),
|
|
bsQueryStr.GetString(),
|
|
lGenFlags | lQryFlags,
|
|
g_Context, pRes->GetWrapper());
|
|
}
|
|
pHandler->Release();
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, hDlg);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (lSync & SEMISYNC)
|
|
{
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->ExecNotificationQuery(bsQueryType.GetString(), bsQueryStr.GetString(),
|
|
lGenFlags | lQryFlags | WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
|
|
g_Context, &pEnum);
|
|
}
|
|
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, hDlg);
|
|
return FALSE;
|
|
}
|
|
|
|
// Create sink for use in NextAsync calls.
|
|
if (lSync & USE_NEXTASYNC)
|
|
{
|
|
CNotSink* pHandler = new CNotSink(pRes); // contructor starts ref count at 1
|
|
pRes->SetNotify(pHandler);
|
|
pHandler->Release();
|
|
}
|
|
|
|
SetInterfaceSecurityEx(pEnum, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
pRes->SetEnum(pEnum);
|
|
pEnum->Release();
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
// Note, this call should fail with WBEM_E_INVALID_PARAMETER because synchronous invocation
|
|
// isn't supported for ExecNotificationQuery due to the continuous nature of events.
|
|
IEnumWbemClassObject* pEnum = NULL;
|
|
{
|
|
CHourGlass hg;
|
|
hres = g_pNamespace->ExecNotificationQuery(bsQueryType.GetString(), bsQueryStr.GetString(),
|
|
lGenFlags | lQryFlags | WBEM_FLAG_FORWARD_ONLY,
|
|
g_Context, &pEnum);
|
|
}
|
|
if (FAILED(hres))
|
|
{
|
|
FormatError(hres, hDlg);
|
|
return FALSE;
|
|
}
|
|
|
|
SetInterfaceSecurityEx(pEnum, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
pRes->SetEnum(pEnum,hres);
|
|
pEnum->Release();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CMainDlg::ExecNotificationQuery()
|
|
{
|
|
// Does not allow multiple semisync notification query dlg
|
|
// ========================================================
|
|
|
|
if ( m_fNotificationQueryResultDlg && SEMISYNC == m_lSync )
|
|
{
|
|
MessageBox(IDS_MULTIPLE_SEMISYNC_NOTIFICATION_QUERY_DLG_MSG, IDS_ERROR, MB_OK | MB_ICONHAND);
|
|
return;
|
|
}
|
|
|
|
wchar_t *pQueryStr = 0;
|
|
wchar_t *pQueryType = 0;
|
|
LONG lQryFlags = 0;
|
|
|
|
CQueryDlg QD(m_hDlg, &lQryFlags, &pQueryStr, &pQueryType);
|
|
INT_PTR nRes = QD.Run();
|
|
|
|
if ((nRes == IDCANCEL) || (nRes == 0) || (!pQueryStr) || (!pQueryType))
|
|
return;
|
|
|
|
// If here, we are ready to execute the query.
|
|
// ===========================================
|
|
|
|
CNotificationQueryResultDlg* pResDlg = new CNotificationQueryResultDlg(m_hDlg, m_lGenFlags, lQryFlags, m_lSync );
|
|
// Pass on invocation method (sync, async..) and related settings for this
|
|
// query and by any further operations (editing/deleting/etc. of an instance).
|
|
|
|
pResDlg->SetCallMethod(m_lSync);
|
|
pResDlg->SetTimeout(Timeout());
|
|
pResDlg->SetBatchCount(BatchCount());
|
|
|
|
wchar_t szDest[512];
|
|
szDest[511] = L'\0';
|
|
char szTitle[1000];
|
|
sprintf(szTitle, "%S: %S", pQueryType, wcsncpy(szDest, pQueryStr, 511));
|
|
|
|
if(lQryFlags & WBEM_FLAG_PROTOTYPE)
|
|
lQryFlags = (lQryFlags & ~WBEM_FLAG_PROTOTYPE) | WBEM_FLAG_MONITOR;
|
|
|
|
if (_ExecNotificationQuery(m_hDlg, m_lGenFlags, lQryFlags, pQueryStr, pQueryType,
|
|
m_lSync, pResDlg, szTitle, Timeout(), BatchCount()))
|
|
{
|
|
pResDlg->RunDetached(this);
|
|
}
|
|
else
|
|
{
|
|
delete pResDlg;
|
|
}
|
|
|
|
delete [] pQueryStr;
|
|
delete [] pQueryType;
|
|
}
|
|
|
|
// ****************************************************************************
|
|
|
|
void CMainDlg::ExecMethod()
|
|
{
|
|
CMethodDlg * pDlg = new CMethodDlg(m_hDlg, m_lGenFlags, m_lSync, Timeout());
|
|
pDlg->RunDetached(this);
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
|
|
class CSuperclassInfoDlg : public CWbemDialog
|
|
{
|
|
protected:
|
|
LPWSTR m_wszSuperclass;
|
|
long m_lMaxLen;
|
|
LONG* m_plQryFlags;
|
|
BOOL m_bIsInstance;
|
|
public:
|
|
CSuperclassInfoDlg(HWND hParent, LPWSTR wszClass, long lMaxLen, LONG* plQryFlags)
|
|
: m_wszSuperclass(wszClass), m_lMaxLen(lMaxLen), m_plQryFlags(plQryFlags),
|
|
m_bIsInstance(FALSE), CWbemDialog(IDD_PARENTINFO, hParent)
|
|
{}
|
|
void SetIsInstance() {m_bIsInstance = TRUE;}
|
|
|
|
protected:
|
|
BOOL OnInitDialog();
|
|
BOOL Verify();
|
|
};
|
|
|
|
class CRenameDlg : public CWbemDialog
|
|
{
|
|
protected:
|
|
LPWSTR m_wszOld;
|
|
long m_lMaxOldLen;
|
|
LPWSTR m_wszNew;
|
|
long m_lMaxNewLen;
|
|
public:
|
|
CRenameDlg(HWND hParent, LPWSTR wszOld, long lMaxOldLen, LPWSTR wszNew, long lMaxNewLen)
|
|
: m_wszOld(wszOld), m_lMaxOldLen(lMaxOldLen), m_wszNew(wszNew), m_lMaxNewLen(lMaxNewLen),
|
|
CWbemDialog(IDD_RENAMEDIALOG, hParent)
|
|
{}
|
|
|
|
protected:
|
|
BOOL OnInitDialog(){return TRUE;};
|
|
BOOL Verify();
|
|
};
|
|
BOOL CRenameDlg::Verify()
|
|
{
|
|
*m_wszOld = 0;
|
|
GetDlgItemTextX(IDC_EDITOLD, m_wszOld, m_lMaxOldLen);
|
|
*m_wszNew = 0;
|
|
GetDlgItemTextX(IDC_EDITNEW, m_wszNew, m_lMaxNewLen);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CSuperclassInfoDlg::OnInitDialog()
|
|
{
|
|
char szFormat[1024];
|
|
SetCheck(IDC_IMMEDIATE_SUBCLASSES, BST_CHECKED);
|
|
if(m_bIsInstance)
|
|
{
|
|
LoadString(GetModuleHandle(NULL), IDS_CLASS_INFO, szFormat, 1024);
|
|
SetWindowText(m_hDlg, szFormat);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CSuperclassInfoDlg::Verify()
|
|
{
|
|
if (GetCheck(IDC_IMMEDIATE_SUBCLASSES) == BST_CHECKED)
|
|
*m_plQryFlags = WBEM_FLAG_SHALLOW;
|
|
else
|
|
*m_plQryFlags = WBEM_FLAG_DEEP;
|
|
|
|
*m_wszSuperclass = 0;
|
|
GetDlgItemTextX(IDC_SUPERCLASS, m_wszSuperclass, m_lMaxLen);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CCreateInstanceDlg::OnInitDialog()
|
|
{
|
|
char szFormat[1024];
|
|
SetCheck(IDC_USE_CLASSOBJ, BST_CHECKED);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CCreateInstanceDlg::Verify()
|
|
{
|
|
if (GetCheck(IDC_USE_CLASSOBJ) == BST_CHECKED)
|
|
*m_plQryFlags = 1;
|
|
else
|
|
*m_plQryFlags = 0;
|
|
|
|
*m_wszClass = 0;
|
|
GetDlgItemTextX(IDC_SUPERCLASS, m_wszClass, m_lMaxLen);
|
|
return TRUE;
|
|
}
|
|
|
|
INT_PTR GetSuperclassInfo(HWND hDlg, LPWSTR pClass, LONG lMaxBuf, LONG* plQryFlags)
|
|
{
|
|
CSuperclassInfoDlg InfoDlg(hDlg, pClass, lMaxBuf, plQryFlags);
|
|
return InfoDlg.Run();
|
|
}
|
|
|
|
INT_PTR GetClassInfo(HWND hDlg, LPWSTR pClass, LONG lMaxBuf, LONG* plQryFlags)
|
|
{
|
|
CSuperclassInfoDlg InfoDlg(hDlg, pClass, lMaxBuf, plQryFlags);
|
|
InfoDlg.SetIsInstance();
|
|
return InfoDlg.Run();
|
|
}
|
|
|
|
class CContextValueDlg : public CWbemDialog
|
|
{
|
|
protected:
|
|
BSTR* m_pstrName;
|
|
VARIANT* m_pvValue;
|
|
BOOL m_bNew;
|
|
|
|
public:
|
|
CContextValueDlg(HWND hParent, BSTR* pstrName, VARIANT* pvValue, BOOL bNew)
|
|
: CWbemDialog(IDD_CONTEXT_PROPERTY, hParent), m_pstrName(pstrName),
|
|
m_pvValue(pvValue), m_bNew(bNew)
|
|
{}
|
|
|
|
BOOL OnInitDialog();
|
|
BOOL Verify();
|
|
|
|
void Refresh();
|
|
};
|
|
|
|
BOOL CContextValueDlg::OnInitDialog()
|
|
{
|
|
// Populate the combo box with the valid prop types
|
|
// ================================================
|
|
|
|
AddStringToCombo(IDC_TYPE_LIST, "CIM_STRING");
|
|
AddStringToCombo(IDC_TYPE_LIST, "CIM_UINT8");
|
|
AddStringToCombo(IDC_TYPE_LIST, "CIM_SINT16");
|
|
AddStringToCombo(IDC_TYPE_LIST, "CIM_SINT32");
|
|
AddStringToCombo(IDC_TYPE_LIST, "CIM_REAL32");
|
|
AddStringToCombo(IDC_TYPE_LIST, "CIM_REAL64");
|
|
AddStringToCombo(IDC_TYPE_LIST, "CIM_BOOLEAN");
|
|
AddStringToCombo(IDC_TYPE_LIST, "CIM_OBJECT");
|
|
|
|
if(!m_bNew)
|
|
EnableWindow(GetDlgItem(IDC_PROPNAME), FALSE);
|
|
|
|
if(*m_pstrName)
|
|
{
|
|
SetDlgItemTextX(IDC_PROPNAME, *m_pstrName);
|
|
}
|
|
|
|
if(V_VT(m_pvValue) != VT_EMPTY)
|
|
{
|
|
LPSTR pTypeStr = TypeToString(V_VT(m_pvValue) & ~VT_ARRAY);
|
|
SendMessage(GetDlgItem(IDC_TYPE_LIST), CB_SELECTSTRING, WPARAM(-1),
|
|
LPARAM(pTypeStr));
|
|
if(V_VT(m_pvValue) & VT_ARRAY)
|
|
SetCheck(IDC_ARRAY, BST_CHECKED);
|
|
|
|
CVar v;
|
|
v.SetVariant(m_pvValue);
|
|
LPSTR szValue = ValueToString(&v);
|
|
SetDlgItemText(IDC_VALUE, szValue);
|
|
}
|
|
else
|
|
{
|
|
SendMessage(GetDlgItem(IDC_TYPE_LIST), CB_SELECTSTRING, WPARAM(-1),
|
|
LPARAM("VT_NULL"));
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CContextValueDlg::Verify()
|
|
{
|
|
WCHAR wszName[1024];
|
|
GetDlgItemTextX(IDC_PROPNAME, wszName, 1024);
|
|
if(*wszName == 0)
|
|
{
|
|
MessageBox(IDS_NO_PROPERTY_NAME, IDS_ERROR, MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
StripTrailingWs(wszName);
|
|
|
|
LPSTR szType = GetCBCurSelString(IDC_TYPE_LIST);
|
|
int nType = StringToType(szType);
|
|
if(nType == VT_NULL)
|
|
{
|
|
MessageBox(IDS_INVALID_PROPERTY_TYPE, IDS_ERROR, MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
if(GetCheck(IDC_ARRAY) == BST_CHECKED)
|
|
{
|
|
nType |= VT_ARRAY;
|
|
}
|
|
|
|
CHAR szValue[1024];
|
|
UINT uRes = GetDlgItemTextA(m_hDlg, IDC_VALUE, szValue, 1024);
|
|
CVar* pVal = StringToValue(szValue, nType);
|
|
if(pVal == NULL)
|
|
{
|
|
MessageBox(IDS_INVALID_PROPERTY_VALUE, IDS_ERROR, MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
// All checked out. Store and succeed
|
|
// ==================================
|
|
|
|
SysFreeString(*m_pstrName);
|
|
*m_pstrName = SysAllocString(wszName);
|
|
VariantClear(m_pvValue);
|
|
pVal->FillVariant(m_pvValue);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
class CContextDlg : public CWbemDialog
|
|
{
|
|
CContext* m_pContext;
|
|
CContext m_Context;
|
|
public:
|
|
CContextDlg(HWND hParent, CContext* pContext)
|
|
: CWbemDialog(IDD_CONTEXT_EDITOR, hParent), m_pContext(pContext)
|
|
{}
|
|
protected:
|
|
BOOL OnInitDialog();
|
|
BOOL Verify();
|
|
BOOL OnCommand(WORD wCode, WORD wID);
|
|
BOOL OnDoubleClick(int nId);
|
|
|
|
void EnableControls(BOOL bEnable);
|
|
void Refresh();
|
|
void OnUse();
|
|
void OnAdd();
|
|
void OnDelete();
|
|
void OnEdit();
|
|
|
|
BSTR GetCurSelEntryName();
|
|
LPSTR MakeListEntry(LPCWSTR wszName, VARIANT& vValue);
|
|
};
|
|
|
|
CContext::CContext() : m_bNull(TRUE), m_pContext(NULL)
|
|
{
|
|
}
|
|
|
|
BOOL CContext::SetNullness(BOOL bNull)
|
|
{
|
|
m_bNull = bNull;
|
|
if(!m_bNull && m_pContext == NULL)
|
|
{
|
|
HRESULT hres = CoCreateInstance(CLSID_WbemContext, NULL,
|
|
CLSCTX_INPROC_SERVER, IID_IWbemContext, (void**)&m_pContext);
|
|
return SUCCEEDED(hres);
|
|
}
|
|
else return TRUE;
|
|
}
|
|
|
|
CContext::~CContext()
|
|
{
|
|
if(m_pContext)
|
|
m_pContext->Release();
|
|
}
|
|
|
|
void CContext::Clear()
|
|
{
|
|
if(m_pContext)
|
|
m_pContext->Release();
|
|
m_pContext = NULL;
|
|
m_bNull = TRUE;
|
|
}
|
|
|
|
|
|
INT_PTR CContext::Edit(HWND hParent)
|
|
{
|
|
CContextDlg Dlg(hParent, this);
|
|
return Dlg.Run();
|
|
}
|
|
|
|
CContext::operator IWbemContext*()
|
|
{
|
|
if(m_bNull)
|
|
return NULL;
|
|
else
|
|
return m_pContext;
|
|
}
|
|
|
|
void CContext::operator=(const CContext& Other)
|
|
{
|
|
m_bNull = Other.m_bNull;
|
|
if(m_pContext)
|
|
m_pContext->Release();
|
|
if(Other.m_pContext)
|
|
Other.m_pContext->Clone(&m_pContext);
|
|
else
|
|
m_pContext = NULL;
|
|
}
|
|
|
|
void CContextDlg::OnUse()
|
|
{
|
|
BOOL bEnable = (GetCheck(IDC_USE_CONTEXT) == BST_CHECKED);
|
|
EnableControls(bEnable);
|
|
m_Context.SetNullness(!bEnable);
|
|
}
|
|
|
|
BOOL CContextDlg::OnCommand(WORD wCode, WORD wID)
|
|
{
|
|
if(wID == IDC_USE_CONTEXT)
|
|
OnUse();
|
|
else if(wID == IDC_ADD_PROP)
|
|
OnAdd();
|
|
else if(wID == IDC_EDIT_PROP)
|
|
OnEdit();
|
|
else if(wID == IDC_DELETE_PROP)
|
|
OnDelete();
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CContextDlg::OnDoubleClick(int nID)
|
|
{
|
|
if(nID == IDC_VALUE_LIST)
|
|
OnEdit();
|
|
return TRUE;
|
|
}
|
|
|
|
void CContextDlg::OnAdd()
|
|
{
|
|
BSTR strName = NULL;
|
|
VARIANT vValue;
|
|
VariantInit(&vValue);
|
|
|
|
CContextValueDlg Dlg(m_hDlg, &strName, &vValue, TRUE);
|
|
INT_PTR nRes = Dlg.Run();
|
|
if(nRes == IDOK)
|
|
{
|
|
m_Context.SetNullness(FALSE);
|
|
m_Context->SetValue(strName, 0, &vValue);
|
|
Refresh();
|
|
}
|
|
SysFreeString(strName);
|
|
VariantClear(&vValue);
|
|
}
|
|
|
|
void CContextDlg::OnEdit()
|
|
{
|
|
BSTR strName = GetCurSelEntryName();
|
|
if(strName == NULL)
|
|
return;
|
|
VARIANT vValue;
|
|
VariantInit(&vValue);
|
|
|
|
m_Context->GetValue(strName, 0, &vValue);
|
|
|
|
CContextValueDlg Dlg(m_hDlg, &strName, &vValue, FALSE);
|
|
INT_PTR nRes = Dlg.Run();
|
|
if(nRes == IDOK)
|
|
{
|
|
m_Context->SetValue(strName, 0, &vValue);
|
|
Refresh();
|
|
}
|
|
SysFreeString(strName);
|
|
VariantClear(&vValue);
|
|
}
|
|
|
|
void CContextDlg::OnDelete()
|
|
{
|
|
BSTR strName = GetCurSelEntryName();
|
|
if(strName == NULL)
|
|
return;
|
|
m_Context->DeleteValue(strName, 0);
|
|
SysAllocString(strName);
|
|
Refresh();
|
|
}
|
|
|
|
LPSTR CContextDlg::MakeListEntry(LPCWSTR wszName, VARIANT& vValue)
|
|
{
|
|
CVar value(&vValue);
|
|
LPSTR TypeString = TypeToString(V_VT(&vValue));
|
|
LPSTR ValueString = ValueToString(&value);
|
|
|
|
char* sz = new char[strlen(TypeString) + strlen(ValueString) +
|
|
wcslen(wszName)*4 + 100];
|
|
|
|
sprintf(sz, "%S\t%s\t%s", wszName, TypeString, ValueString);
|
|
return sz;
|
|
}
|
|
|
|
BSTR CContextDlg::GetCurSelEntryName()
|
|
{
|
|
LPSTR szEntry = GetLBCurSelString(IDC_VALUE_LIST);
|
|
if(szEntry == NULL)
|
|
return NULL;
|
|
char* pc = strchr(szEntry, '\t');
|
|
if(pc) *pc = 0;
|
|
LPWSTR wszName = CreateUnicode(szEntry);
|
|
delete [] szEntry;
|
|
BSTR strName = SysAllocString(wszName);
|
|
delete [] wszName;
|
|
return strName;
|
|
}
|
|
|
|
void CContextDlg::Refresh()
|
|
{
|
|
SendMessage(GetDlgItem(IDC_VALUE_LIST), LB_RESETCONTENT, 0, 0);
|
|
|
|
IWbemContext* pContext = m_Context.GetStoredContext();
|
|
if(pContext)
|
|
{
|
|
pContext->BeginEnumeration(0);
|
|
BSTR strName;
|
|
VARIANT vValue;
|
|
VariantInit(&vValue);
|
|
while(pContext->Next(0, &strName, &vValue) == S_OK)
|
|
{
|
|
char* szEntry = MakeListEntry(strName, vValue);
|
|
AddStringToList(IDC_VALUE_LIST, szEntry);
|
|
delete [] szEntry;
|
|
VariantClear(&vValue);
|
|
}
|
|
pContext->EndEnumeration();
|
|
}
|
|
|
|
if(m_Context.IsNull())
|
|
{
|
|
SetCheck(IDC_USE_CONTEXT, BST_UNCHECKED);
|
|
EnableControls(FALSE);
|
|
}
|
|
else
|
|
{
|
|
SetCheck(IDC_USE_CONTEXT, BST_CHECKED);
|
|
}
|
|
}
|
|
|
|
BOOL CContextDlg::OnInitDialog()
|
|
{
|
|
m_Context = *m_pContext;
|
|
|
|
// Set tabs in the list box
|
|
// ========================
|
|
LONG Tabs[] = { 80, 120, 170 };
|
|
int TabCount = 3;
|
|
|
|
SendMessage(GetDlgItem(IDC_VALUE_LIST), LB_SETTABSTOPS,
|
|
(WPARAM) TabCount, (LPARAM) Tabs);
|
|
|
|
SendMessage(GetDlgItem(IDC_VALUE_LIST), LB_SETHORIZONTALEXTENT, 1000, 0);
|
|
|
|
Refresh();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CContextDlg::EnableControls(BOOL bEnable)
|
|
{
|
|
EnableWindow(GetDlgItem(IDC_VALUE_LIST), bEnable);
|
|
EnableWindow(GetDlgItem(IDC_ADD_PROP), bEnable);
|
|
EnableWindow(GetDlgItem(IDC_EDIT_PROP), bEnable);
|
|
EnableWindow(GetDlgItem(IDC_DELETE_PROP), bEnable);
|
|
}
|
|
|
|
CContextDlg::Verify()
|
|
{
|
|
*m_pContext = m_Context;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
CMainDlg::~CMainDlg()
|
|
{
|
|
PostQuitMessage(0);
|
|
}
|
|
|
|
BOOL CMainDlg::OnInitDialog()
|
|
{
|
|
CenterOnScreen(m_hDlg);
|
|
// if(!gbAdvanced)
|
|
// {
|
|
// ShowWindow(GetDlgItem(IDC_ENABLE_PRIVILEGES), SW_HIDE);
|
|
// }
|
|
|
|
ConnectButtons(FALSE);
|
|
SetDlgItemTextWC(m_hDlg, IDC_NAMESPACE, gNameSpace);
|
|
|
|
CheckRadioButton(m_hDlg, IDC_ASYNC, IDC_SEMISYNC,
|
|
(m_lSync & ASYNC) ? IDC_ASYNC : ((m_lSync & SEMISYNC) ? IDC_SEMISYNC : IDC_SYNC));
|
|
SetDlgItemText(IDC_TIMEOUT, "5000");
|
|
SetDlgItemText(IDC_BATCH, "10");
|
|
|
|
SetFocus(GetDlgItem(IDC_CONNECT));
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CMainDlg::OnCommand(WORD wNotifyCode, WORD wID)
|
|
{
|
|
|
|
switch (wID)
|
|
{
|
|
case IDC_MENU_EXIT:
|
|
case IDC_CONNECT:
|
|
Connect(FALSE);
|
|
return TRUE;
|
|
case IDC_WBEMHELP:
|
|
OpenHelp();
|
|
return TRUE;
|
|
|
|
case IDC_BIND:
|
|
Connect(TRUE);
|
|
return TRUE;
|
|
|
|
case IDC_CREATE_CLASS:
|
|
CreateClass();
|
|
return TRUE;
|
|
case IDC_GET_CLASSES:
|
|
GetClasses();
|
|
return TRUE;
|
|
|
|
case IDC_EDIT_CLASS:
|
|
EditClass();
|
|
return TRUE;
|
|
|
|
case IDC_DELETE_CLASS:
|
|
DeleteClass();
|
|
return TRUE;
|
|
|
|
case IDC_CREATE_INSTANCE:
|
|
CreateInstance();
|
|
return TRUE;
|
|
case IDC_GET_INSTANCES:
|
|
GetInstances();
|
|
return TRUE;
|
|
|
|
case IDC_EDIT_INSTANCE:
|
|
EditInstance();
|
|
return TRUE;
|
|
|
|
case IDC_EXEC_METHOD:
|
|
ExecMethod();
|
|
return TRUE;
|
|
|
|
case IDC_DELETE_INSTANCE:
|
|
DeleteInstance();
|
|
return TRUE;
|
|
|
|
case IDC_QUERY:
|
|
ExecQuery();
|
|
return TRUE;
|
|
|
|
case IDC_NOTIFICATION_QUERY:
|
|
ExecNotificationQuery();
|
|
return TRUE;
|
|
|
|
case IDC_OPEN_NS:
|
|
OpenNs();
|
|
return TRUE;
|
|
|
|
case IDC_REFRESH:
|
|
CreateRefresher();
|
|
return TRUE;
|
|
case IDC_CONTEXT:
|
|
EditContext();
|
|
return TRUE;
|
|
case IDC_ENABLE_PRIVILEGES:
|
|
{
|
|
// From common\genutils.cpp
|
|
HRESULT hRes = EnableAllPrivileges(TOKEN_PROCESS);
|
|
BOOL bRes = SUCCEEDED(hRes);
|
|
if (bRes)
|
|
EnableWindow(GetDlgItem(IDC_ENABLE_PRIVILEGES), FALSE);
|
|
return bRes;
|
|
}
|
|
case IDC_USE_AMENDED:
|
|
if (GetCheck(IDC_USE_AMENDED) == BST_CHECKED)
|
|
m_lGenFlags |= WBEM_FLAG_USE_AMENDED_QUALIFIERS;
|
|
else
|
|
m_lGenFlags &= ~WBEM_FLAG_USE_AMENDED_QUALIFIERS;
|
|
return TRUE;
|
|
case IDC_DIRECT_READ:
|
|
if (GetCheck(IDC_DIRECT_READ) == BST_CHECKED)
|
|
m_lGenFlags |= WBEM_FLAG_DIRECT_READ;
|
|
else
|
|
m_lGenFlags &= ~WBEM_FLAG_DIRECT_READ;
|
|
return TRUE;
|
|
case IDC_USE_NEXTASYNC:
|
|
if (GetCheck(IDC_USE_NEXTASYNC) == BST_CHECKED)
|
|
m_lSync |= USE_NEXTASYNC;
|
|
else
|
|
m_lSync &= ~USE_NEXTASYNC;
|
|
EnableWindow(GetDlgItem(IDC_TIMEOUT), !(m_lSync & USE_NEXTASYNC));
|
|
return TRUE;
|
|
|
|
case IDC_ASYNC:
|
|
case IDC_SYNC:
|
|
case IDC_SEMISYNC:
|
|
// Can ignore USE_NEXTASYNC checkbox because we are changing to or from
|
|
// semisync which means this checkbox either was clear or is now cleared.
|
|
if (GetCheck(IDC_ASYNC) == BST_CHECKED)
|
|
{
|
|
m_lSync = ASYNC;
|
|
SetCheck(IDC_USE_NEXTASYNC, BST_UNCHECKED);
|
|
}
|
|
else if (GetCheck(IDC_SYNC) == BST_CHECKED)
|
|
{
|
|
m_lSync = SYNC;
|
|
SetCheck(IDC_USE_NEXTASYNC, BST_UNCHECKED);
|
|
}
|
|
else if (GetCheck(IDC_SEMISYNC) == BST_CHECKED)
|
|
{
|
|
m_lSync = SEMISYNC;
|
|
}
|
|
EnableWindow(GetDlgItem(IDC_BATCH), !(m_lSync & ASYNC));
|
|
EnableWindow(GetDlgItem(IDC_TIMEOUT), (m_lSync & SEMISYNC));
|
|
EnableWindow(GetDlgItem(IDC_USE_NEXTASYNC), (m_lSync & SEMISYNC));
|
|
return TRUE;
|
|
case IDC_OPEN:
|
|
Open();
|
|
return TRUE;
|
|
|
|
case IDC_ADDOBJECT:
|
|
AddObject();
|
|
return TRUE;
|
|
|
|
case IDC_DELETEOBJECT:
|
|
DeleteObject();
|
|
return TRUE;
|
|
|
|
case IDC_RENAMEOBJECT:
|
|
RenameObject();
|
|
return TRUE;
|
|
|
|
case IDC_GETOBJECTSECURITY:
|
|
GetObjectSecurity();
|
|
return TRUE;
|
|
|
|
case IDC_SETOBJECTSECURITY:
|
|
SetObjectSecurity();
|
|
return TRUE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
LONG CMainDlg::Timeout()
|
|
{
|
|
wchar_t wszTimeout[32];
|
|
*wszTimeout = 0;
|
|
LONG lTimeout = 0;
|
|
|
|
::GetDlgItemTextX(m_hDlg, IDC_TIMEOUT, wszTimeout, 32);
|
|
if (*wszTimeout != 0)
|
|
lTimeout = _wtol(wszTimeout);
|
|
if (lTimeout < 0)
|
|
lTimeout = WBEM_INFINITE;
|
|
|
|
return lTimeout;
|
|
}
|
|
|
|
ULONG CMainDlg::BatchCount()
|
|
{
|
|
wchar_t wszBatch[32];
|
|
*wszBatch = 0;
|
|
ULONG nBatch = 1;
|
|
|
|
::GetDlgItemTextX(m_hDlg, IDC_BATCH, wszBatch, 32);
|
|
if (*wszBatch != 0)
|
|
nBatch = _wtol(wszBatch);
|
|
if (nBatch == 0)
|
|
nBatch = 1;
|
|
|
|
return nBatch;
|
|
}
|
|
|
|
CRefresherDlg::CRefresherDlg(HWND hParent, LONG lGenFlags)
|
|
: CQueryResultDlg(hParent, lGenFlags, WBEM_FLAG_DEEP)
|
|
{
|
|
CoCreateInstance(CLSID_WbemRefresher, NULL,
|
|
CLSCTX_INPROC_SERVER, IID_IWbemRefresher, (void**)&m_pRefresher);
|
|
m_pRefresher->QueryInterface(IID_IWbemConfigureRefresher,
|
|
(void**)&m_pCreator);
|
|
}
|
|
|
|
CRefresherDlg::~CRefresherDlg()
|
|
{
|
|
// Release all allocated enumerators
|
|
while ( m_apEnums.Size() != 0 )
|
|
{
|
|
IEnumWbemClassObject* pEnum = (IEnumWbemClassObject*) m_apEnums.GetAt( 0 );
|
|
if ( NULL != pEnum )
|
|
{
|
|
pEnum->Release();
|
|
}
|
|
m_apEnums.RemoveAt( 0 );
|
|
}
|
|
|
|
m_pRefresher->Release();
|
|
m_pCreator->Release();
|
|
}
|
|
|
|
BOOL CRefresherDlg::OnInitDialog()
|
|
{
|
|
SetTitle("REFRESHER");
|
|
ShowWindow(GetDlgItem(IDC_STATUS), SW_HIDE);
|
|
ShowWindow(GetDlgItem(IDC_NUM_BATCH), SW_HIDE);
|
|
if(!CQueryResultDlg::OnInitDialog())
|
|
return FALSE;
|
|
ShowWindow(GetDlgItem(IDC_REFRESH), SW_SHOWNORMAL);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CRefresherDlg::OnCommand(WORD wCode, WORD wID)
|
|
{
|
|
if(wID == IDC_REFRESH)
|
|
{
|
|
OnRefresh();
|
|
return TRUE;
|
|
}
|
|
else return CQueryResultDlg::OnCommand(wCode, wID);
|
|
}
|
|
|
|
void CRefresherDlg::OnRefresh()
|
|
{
|
|
HRESULT hres = m_pRefresher->Refresh(0);
|
|
if(FAILED(hres))
|
|
{
|
|
FormatError(hres, NULL);
|
|
}
|
|
}
|
|
|
|
BOOL CRefresherDlg::DeleteListElement(LRESULT nSel)
|
|
{
|
|
HRESULT hres = m_pCreator->Remove(PtrToLong(m_aIds[(DWORD)nSel]), 0);
|
|
if(FAILED(hres))
|
|
{
|
|
FormatError(hres, NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
m_aIds.RemoveAt((DWORD)nSel);
|
|
|
|
// If this is an enumerator, we should release it before we remove it
|
|
IEnumWbemClassObject* pEnum = (IEnumWbemClassObject*) m_apEnums.GetAt( (DWORD)nSel );
|
|
|
|
if ( NULL != pEnum )
|
|
{
|
|
pEnum->Release();
|
|
}
|
|
m_apEnums.RemoveAt((DWORD)nSel);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
IWbemClassObject* CRefresherDlg::AddNewElement()
|
|
{
|
|
if(g_pNamespace == NULL)
|
|
{
|
|
MessageBox(IDS_NO_CONNECTION, IDS_ERROR, MB_OK);
|
|
return NULL;
|
|
}
|
|
wchar_t ObjPath[2560];
|
|
|
|
INT_PTR iRet = GetRefrObjectPath(m_hDlg, ObjPath, 2560);
|
|
if(iRet == IDCANCEL)
|
|
return NULL;
|
|
|
|
if (wcslen(ObjPath) == 0)
|
|
{
|
|
MessageBox(IDS_NO_PATH, IDS_ERROR, MB_OK);
|
|
return NULL;
|
|
}
|
|
|
|
IWbemClassObject* pObj = NULL;
|
|
IWbemHiPerfEnum* pEnum = NULL;
|
|
long lId;
|
|
HRESULT hres = WBEM_S_NO_ERROR;
|
|
|
|
|
|
|
|
// iRet for whether we want to add an object or an enum
|
|
|
|
if ( IDOK == iRet )
|
|
{
|
|
hres = m_pCreator->AddObjectByPath(g_pNamespace, ObjPath,
|
|
m_lGenFlags, g_Context, &pObj, &lId);
|
|
if(FAILED(hres))
|
|
{
|
|
FormatError(hres, NULL);
|
|
return NULL;
|
|
}
|
|
#ifdef _WIN64
|
|
m_aIds.Add(IntToPtr(lId)); // ok since we are really using safearray for dword
|
|
#else
|
|
m_aIds.Add((void*)lId);
|
|
#endif
|
|
// Fakes out the Enumerator List
|
|
m_apEnums.Add( NULL );
|
|
return pObj;
|
|
}
|
|
|
|
// Add an enumerator to the dialog
|
|
hres = m_pCreator->AddEnum(g_pNamespace, ObjPath,
|
|
m_lGenFlags, g_Context, &pEnum, &lId);
|
|
if(FAILED(hres))
|
|
{
|
|
FormatError(hres, NULL);
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef _WIN64
|
|
m_aIds.Add(IntToPtr(lId)); // ok since we are really using safearray for dword
|
|
#else
|
|
m_aIds.Add((void*)lId);
|
|
#endif
|
|
m_apEnums.Add( (void*) pEnum );
|
|
|
|
// Fakes out the object list
|
|
m_InternalArray.Add( NULL );
|
|
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
|
|
// Allocate a large enough buffer
|
|
char* szTemp = new char[(wcslen( ObjPath ) * 2) + 64];
|
|
sprintf( szTemp, "%S Enumerator, Id: %d", ObjPath, lId );
|
|
SendMessage(hList, LB_ADDSTRING, 0, LPARAM(szTemp));
|
|
delete [] szTemp;
|
|
|
|
SetNumItems(SendMessage(hList, LB_GETCOUNT, 0, 0));
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
BOOL CRefresherDlg::OnDoubleClick(int nID)
|
|
{
|
|
if(nID != IDC_OBJECT_LIST) return FALSE;
|
|
HWND hList = GetDlgItem(IDC_OBJECT_LIST);
|
|
|
|
LRESULT nSel = SendMessage(hList, LB_GETCURSEL, 0, 0);
|
|
|
|
if (nSel == LB_ERR)
|
|
return TRUE;
|
|
|
|
IWbemHiPerfEnum* pEnum = (IWbemHiPerfEnum*) m_apEnums.GetAt( (DWORD)nSel );
|
|
|
|
if ( NULL != pEnum )
|
|
{
|
|
char* szTemp = new char[SendMessage( hList, LB_GETTEXTLEN, nSel, 0 )+10];
|
|
SendMessage( hList, LB_GETTEXT, nSel, (LPARAM) szTemp );
|
|
|
|
// Run the dialog modal
|
|
CRefresherEnumDlg* pDlg = new CRefresherEnumDlg(m_hDlg, m_lGenFlags, pEnum, szTemp);
|
|
pDlg->Run( NULL );
|
|
|
|
delete pDlg;
|
|
delete [] szTemp;
|
|
SendMessage(hList, LB_SETCURSEL, nSel, 0);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return CQueryResultDlg::OnDoubleClick( nID );
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
CRefresherEnumDlg::CRefresherEnumDlg(HWND hParent, LONG lGenFlags, IWbemHiPerfEnum* pEnum,
|
|
char* pszName)
|
|
: CQueryResultDlg(hParent, lGenFlags, WBEM_FLAG_DEEP), m_pEnum(pEnum), m_pszName(pszName)
|
|
{
|
|
|
|
if ( NULL != m_pEnum )
|
|
{
|
|
m_pEnum->AddRef();
|
|
}
|
|
}
|
|
|
|
CRefresherEnumDlg::~CRefresherEnumDlg()
|
|
{
|
|
if ( NULL != m_pEnum )
|
|
{
|
|
m_pEnum->Release();
|
|
}
|
|
}
|
|
|
|
BOOL CRefresherEnumDlg::OnInitDialog()
|
|
{
|
|
// Set the dialog title
|
|
char* szTemp = new char[strlen(m_pszName)+64];
|
|
sprintf( szTemp, "REFRESHER: %s", m_pszName );
|
|
SetTitle(szTemp);
|
|
delete [] szTemp;
|
|
|
|
ShowWindow(GetDlgItem(IDC_STATUS), SW_HIDE);
|
|
ShowWindow(GetDlgItem(IDC_NUM_BATCH), SW_HIDE);
|
|
if(!CQueryResultDlg::OnInitDialog())
|
|
return FALSE;
|
|
|
|
// Iterate the enumerator and add all its objects into the list
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
IWbemClassObject* pObj = NULL;
|
|
ULONG nNumObjects = 0,
|
|
nNumReturned = 0;
|
|
|
|
// Find out how many objects to retrieve then get them
|
|
// and stick them in the dialog
|
|
|
|
// Don't pass flags on this call
|
|
m_pEnum->GetObjects( 0L, 0, NULL, &nNumObjects );
|
|
|
|
if ( nNumObjects > 0 )
|
|
{
|
|
IWbemObjectAccess** apObjAccess = new IWbemObjectAccess*[nNumObjects];
|
|
|
|
if ( NULL != apObjAccess )
|
|
{
|
|
// Don't pass flags on this call
|
|
hr = m_pEnum->GetObjects( 0L, nNumObjects, apObjAccess, &nNumReturned );
|
|
|
|
if ( SUCCEEDED( hr ) )
|
|
{
|
|
IWbemClassObject* pClassObj = NULL;
|
|
|
|
for ( ULONG n = 0; SUCCEEDED( hr ) && n < nNumReturned; n++ )
|
|
{
|
|
hr = apObjAccess[n]->QueryInterface( IID_IWbemClassObject, (void**) &pClassObj );
|
|
|
|
if ( SUCCEEDED( hr ) )
|
|
{
|
|
AddObject( pClassObj );
|
|
apObjAccess[n]->Release();
|
|
pClassObj->Release();
|
|
}
|
|
}
|
|
}
|
|
delete [] apObjAccess;
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
|
|
if ( FAILED( hr ) )
|
|
{
|
|
FormatError(hr, NULL);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
CHourGlass::CHourGlass()
|
|
{
|
|
m_hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
}
|
|
|
|
CHourGlass::~CHourGlass()
|
|
{
|
|
SetCursor(m_hCursor);
|
|
}
|
|
|
|
HRESULT EnableAllPrivileges(DWORD dwTokenType)
|
|
{
|
|
// Open thread token
|
|
// =================
|
|
|
|
HANDLE hToken = NULL;
|
|
BOOL bRes;
|
|
|
|
switch (dwTokenType)
|
|
{
|
|
case TOKEN_THREAD:
|
|
bRes = OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, TRUE, &hToken);
|
|
break;
|
|
case TOKEN_PROCESS:
|
|
bRes = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, &hToken);
|
|
break;
|
|
}
|
|
if(!bRes)
|
|
return WBEM_E_ACCESS_DENIED;
|
|
|
|
// Get the privileges
|
|
// ==================
|
|
|
|
DWORD dwLen;
|
|
TOKEN_USER tu;
|
|
memset(&tu,0,sizeof(TOKEN_USER));
|
|
bRes = GetTokenInformation(hToken, TokenPrivileges, &tu, sizeof(TOKEN_USER), &dwLen);
|
|
|
|
BYTE* pBuffer = new BYTE[dwLen];
|
|
if(pBuffer == NULL)
|
|
{
|
|
CloseHandle(hToken);
|
|
return WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
|
|
bRes = GetTokenInformation(hToken, TokenPrivileges, pBuffer, dwLen,
|
|
&dwLen);
|
|
if(!bRes)
|
|
{
|
|
CloseHandle(hToken);
|
|
delete [] pBuffer;
|
|
return WBEM_E_ACCESS_DENIED;
|
|
}
|
|
|
|
// Iterate through all the privileges and enable them all
|
|
// ======================================================
|
|
|
|
TOKEN_PRIVILEGES* pPrivs = (TOKEN_PRIVILEGES*)pBuffer;
|
|
for(DWORD i = 0; i < pPrivs->PrivilegeCount; i++)
|
|
{
|
|
pPrivs->Privileges[i].Attributes |= SE_PRIVILEGE_ENABLED;
|
|
}
|
|
|
|
// Store the information back into the token
|
|
// =========================================
|
|
|
|
bRes = AdjustTokenPrivileges(hToken, FALSE, pPrivs, 0, NULL, NULL);
|
|
delete [] pBuffer;
|
|
CloseHandle(hToken);
|
|
|
|
if(!bRes)
|
|
return WBEM_E_ACCESS_DENIED;
|
|
else
|
|
return WBEM_S_NO_ERROR;
|
|
}
|
|
void CMainDlg::Open()
|
|
{
|
|
|
|
wchar_t ObjPath[2560];
|
|
int iRet = (int) GetObjectPath(m_hDlg, ObjPath, 2560);
|
|
if(iRet == IDCANCEL)
|
|
return;
|
|
|
|
if (wcslen(ObjPath) == 0)
|
|
{
|
|
MessageBox(IDS_NO_PATH, IDS_ERROR, MB_OK);
|
|
return;
|
|
}
|
|
|
|
if (g_pNamespace == 0)
|
|
{
|
|
MessageBox(IDS_NO_INITIAL_CONNECTION, IDS_ERROR, MB_OK);
|
|
return;
|
|
}
|
|
|
|
IWbemServicesEx* pNewNs = NULL;
|
|
CBString bsObjPath(ObjPath);
|
|
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if (m_lSync & ASYNC)
|
|
{
|
|
|
|
IUnknown *pUnknown=NULL;
|
|
|
|
CTestNotify* pSink=new CTestNotify(1);
|
|
|
|
res=g_pServicesEx->OpenAsync(bsObjPath.GetString(), 0,
|
|
m_lGenFlags,
|
|
g_Context, CUnsecWrapEx(pSink));
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
pSink->WaitForSignal(INFINITE);
|
|
res = pSink->GetStatusCode();
|
|
if(SUCCEEDED(res))
|
|
{
|
|
pUnknown=pSink->GetInterface();
|
|
if(pUnknown)
|
|
{
|
|
res = pUnknown->QueryInterface(IID_IWbemServicesEx, (void**)&pNewNs);
|
|
pUnknown->Release();
|
|
}
|
|
else
|
|
res = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
pSink->Release();
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResultEx* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pServicesEx->Open(bsObjPath.GetString(), 0,
|
|
m_lGenFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, NULL, &pCallRes);
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(Timeout(), &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::OpenNamespace call
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = pCallRes->GetResult(0, 0, IID_IWbemServicesEx, (LPVOID *) &pNewNs); // don't use timeout since object should be available
|
|
}
|
|
}
|
|
|
|
pCallRes->Release();
|
|
}
|
|
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
res = g_pServicesEx->Open(bsObjPath.GetString(), 0,
|
|
m_lGenFlags,
|
|
g_Context, &pNewNs, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, m_hDlg, pErrorObj);
|
|
return;
|
|
}
|
|
|
|
g_pNamespace->Release();
|
|
g_pNamespace = pNewNs;
|
|
SetInterfaceSecurityEx(g_pNamespace, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
|
|
wcscat(gNameSpace, L":");
|
|
wcscat(gNameSpace, bsObjPath.GetString());
|
|
SetDlgItemTextWC(m_hDlg, IDC_NAMESPACE, gNameSpace);
|
|
|
|
SysFreeString(g_strNamespace);
|
|
g_strNamespace = SysAllocString(gNameSpace);
|
|
}
|
|
|
|
void CMainDlg::DoServicesExGenObject(int iOpt)
|
|
{
|
|
wchar_t ObjPath[2560];
|
|
*ObjPath = 0;
|
|
|
|
int iRet = (int) GetObjectPath(m_hDlg, ObjPath, 2560);
|
|
if (iRet == IDCANCEL)
|
|
return;
|
|
|
|
if (wcslen(ObjPath) == 0)
|
|
return;
|
|
|
|
CBString bsObjPath(ObjPath);
|
|
HRESULT res = 0;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if (m_lSync & ASYNC)
|
|
{
|
|
MessageBox(IDS_ASYNC_NOT_SUPPORTED, IDS_ERROR, MB_OK);
|
|
return;
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResultEx* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
switch (iOpt)
|
|
{
|
|
case IDC_ADDOBJECT:
|
|
// Link
|
|
res = E_NOTIMPL;
|
|
break;
|
|
|
|
case IDC_DELETEOBJECT:
|
|
// Unlink
|
|
res = E_NOTIMPL;
|
|
break;
|
|
|
|
|
|
}
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
LONG lTimeout = Timeout();
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(lTimeout, &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::DeleteIntance call
|
|
}
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
|
|
switch (iOpt)
|
|
{
|
|
case IDC_ADDOBJECT:
|
|
// Link
|
|
res = E_NOTIMPL;
|
|
break;
|
|
|
|
case IDC_DELETEOBJECT:
|
|
// Unlink
|
|
res = E_NOTIMPL;
|
|
break;
|
|
|
|
|
|
}
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, m_hDlg, pErrorObj);
|
|
}
|
|
}
|
|
|
|
void CMainDlg::AddObject()
|
|
{
|
|
DoServicesExGenObject(IDC_ADDOBJECT);
|
|
}
|
|
|
|
void CMainDlg::DeleteObject()
|
|
{
|
|
wchar_t ObjPath[2560];
|
|
*ObjPath = 0;
|
|
|
|
INT_PTR iRet = GetObjectPath(m_hDlg, ObjPath, 2560);
|
|
if (iRet == IDCANCEL)
|
|
return;
|
|
|
|
if (wcslen(ObjPath) == 0)
|
|
return;
|
|
|
|
CBString bsObjPath(ObjPath);
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if (m_lSync & ASYNC)
|
|
{
|
|
CHourGlass hg;
|
|
CTestNotify* pNtfy = new CTestNotify(1);
|
|
|
|
res = g_pServicesEx->DeleteObjectAsync(bsObjPath.GetString(),
|
|
m_lGenFlags | WBEM_FLAG_SEND_STATUS,
|
|
g_Context, CUnsecWrap(pNtfy));
|
|
|
|
if (SUCCEEDED(res))
|
|
{
|
|
pNtfy->WaitForSignal(INFINITE);
|
|
|
|
res = pNtfy->GetStatusCode(&pErrorObj);
|
|
}
|
|
pNtfy->Release();
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResult* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pServicesEx->DeleteObject(bsObjPath.GetString(),
|
|
m_lGenFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, &pCallRes);
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
LONG lTimeout = Timeout();
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(lTimeout, &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::DeleteIntance call
|
|
}
|
|
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
res = g_pServicesEx->DeleteObject(bsObjPath.GetString(), m_lGenFlags,
|
|
g_Context, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, m_hDlg, pErrorObj);
|
|
}
|
|
}
|
|
|
|
|
|
void CMainDlg::GetObjectSecurity()
|
|
{
|
|
::MessageBox(NULL, "Show me the code", "help!", MB_OK);
|
|
}
|
|
|
|
void CMainDlg::SetObjectSecurity()
|
|
{
|
|
::MessageBox(NULL, "Show me the code", "help!", MB_OK);
|
|
}
|
|
|
|
void CMainDlg::RenameObject()
|
|
{
|
|
WCHAR wsOld[512], wsNew[512];
|
|
CRenameDlg InfoDlg(m_hDlg, wsOld, 512, wsNew, 512);
|
|
if(IDOK != InfoDlg.Run())
|
|
return;
|
|
|
|
CBString bsOld(wsOld);
|
|
CBString bsNew(wsNew);
|
|
HRESULT res;
|
|
IWbemClassObject* pErrorObj = NULL;
|
|
|
|
// Asynchronous
|
|
if (m_lSync & ASYNC)
|
|
{
|
|
MessageBox(IDS_ASYNC_NOT_SUPPORTED, IDS_ERROR, MB_OK);
|
|
return;
|
|
}
|
|
|
|
// Semisynchronous
|
|
else if (m_lSync & SEMISYNC)
|
|
{
|
|
IWbemCallResultEx* pCallRes = NULL;
|
|
CHourGlass hg;
|
|
res = g_pServicesEx->RenameObject(bsOld.GetString(), bsNew.GetString(),
|
|
m_lGenFlags | WBEM_FLAG_RETURN_IMMEDIATELY,
|
|
g_Context, &pCallRes);
|
|
if (SUCCEEDED(res))
|
|
{
|
|
LONG lStatus;
|
|
LONG lTimeout = Timeout();
|
|
SetInterfaceSecurityEx(pCallRes, gpAuthIdentity, gpPrincipal, gdwAuthLevel, gdwImpLevel);
|
|
while ((res = pCallRes->GetCallStatus(lTimeout, &lStatus)) == WBEM_S_TIMEDOUT)
|
|
{
|
|
// wait
|
|
}
|
|
if (res == WBEM_S_NO_ERROR)
|
|
{
|
|
res = (HRESULT)lStatus; // lStatus is the final result of the above IWbemServices::DeleteIntance call
|
|
}
|
|
pCallRes->Release();
|
|
}
|
|
}
|
|
|
|
// Synchronous
|
|
else
|
|
{
|
|
CHourGlass hg;
|
|
|
|
res = g_pServicesEx->RenameObject(bsOld.GetString(), bsNew.GetString(),
|
|
m_lGenFlags,
|
|
g_Context, NULL);
|
|
}
|
|
|
|
if (FAILED(res))
|
|
{
|
|
FormatError(res, m_hDlg, pErrorObj);
|
|
}
|
|
|
|
|
|
}
|