archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-xp/Source/XPSP1/NT/admin/wmi/wbem/winmgmt/wbemtest/wbemtest.cpp

5035 lines
130 KiB
Raw Permalink Blame History

/*++
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);
}
}