API tools faq
paste
Guest User

Untitled

a guest
Sep 11th, 2018
90
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 26.44 KB | None | 0 0
raw download clone embed print report
  1. How to get a instance of Win32_SecurityDescriptor in WMI?
  2. #include "StdAfx.h"
  3. #include "ADWMISearch.h"
  4.  
  5. #include <comdef.h>
  6. # pragma comment(lib, "wbemuuid.lib")
  7. # pragma comment(lib, "credui.lib")
  8. # pragma comment(lib, "comsupp.lib")
  9. #include <wincred.h>
  10. #include <strsafe.h>
  11. #include <iostream>
  12. using namespace std;
  13.  
  14. DWORD ADWMISearch::WIN32_FROM_HRESULT_alternate(HRESULT hr)
  15. {
  16. DWORD dwResult;
  17. if (hr < 0)
  18. {
  19. dwResult = (DWORD) hr;
  20. return dwResult;
  21. }
  22. else
  23. {
  24. MyMessageBox_Error(_T("WIN32_FROM_HRESULT_alternate Error."), _T("Error"));
  25. return -1;
  26. }
  27. }
  28.  
  29. IWbemServices* ADWMISearch::connect(CString strServerName, CString strServerIP, CString strDomainName, CString strUsername,
  30. CString strPassword)
  31. {
  32. CString strComputerName = strServerName;
  33. CString strFullUsername; //_T("adtest\Administrator")
  34. if (strDomainName == _T(""))
  35. {
  36. strUsername = _T("");
  37. strFullUsername = _T("");
  38. strPassword = _T("");
  39. }
  40. else
  41. {
  42. strFullUsername = strDomainName + _T("\") + strUsername;
  43. }
  44.  
  45.  
  46. HRESULT hres;
  47.  
  48. // Step 1: --------------------------------------------------
  49. // Initialize COM. ------------------------------------------
  50.  
  51. hres = CoInitializeEx(0, COINIT_MULTITHREADED);
  52. if (FAILED(hres))
  53. {
  54. //cout << "Failed to initialize COM library. Error code = 0x"
  55. // << hex << hres << endl;
  56. MyMessageBox_Error(_T("connect"));
  57. return NULL; // Program has failed.
  58. }
  59.  
  60. // Step 2: --------------------------------------------------
  61. // Set general COM security levels --------------------------
  62.  
  63. hres = CoInitializeSecurity(
  64. NULL,
  65. -1, // COM authentication
  66. NULL, // Authentication services
  67. NULL, // Reserved
  68. RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication
  69. RPC_C_IMP_LEVEL_IDENTIFY, // Default Impersonation
  70. NULL, // Authentication info
  71. EOAC_NONE, // Additional capabilities
  72. NULL // Reserved
  73. );
  74.  
  75. //char aaa[100];
  76. //sprintf(aaa, "%x", hres);
  77.  
  78. if (FAILED(hres) && hres != RPC_E_TOO_LATE)
  79. {
  80. //cout << "Failed to initialize security. Error code = 0x"
  81. // << hex << hres << endl;
  82. CoUninitialize();
  83. MyMessageBox_Error(_T("connect"));
  84. return NULL; // Program has failed.
  85. }
  86.  
  87. // Step 3: ---------------------------------------------------
  88. // Obtain the initial locator to WMI -------------------------
  89.  
  90. IWbemLocator *pLoc = NULL;
  91.  
  92. hres = CoCreateInstance(
  93. CLSID_WbemLocator,
  94. 0,
  95. CLSCTX_INPROC_SERVER,
  96. IID_IWbemLocator, (LPVOID *) &pLoc);
  97.  
  98. if (FAILED(hres))
  99. {
  100. CoUninitialize();
  101. MyMessageBox_Error(_T("connect"));
  102. return NULL; // Program has failed.
  103. }
  104.  
  105. // Step 4: -----------------------------------------------------
  106. // Connect to WMI through the IWbemLocator::ConnectServer method
  107.  
  108. IWbemServices *pSvc = NULL;
  109.  
  110. bool useToken = TRUE;
  111. bool useNTLM = FALSE;
  112. // Get the user name and password for the remote computer
  113. /*
  114. CREDUI_INFO cui;
  115. bool useToken = TRUE;
  116. bool useNTLM = FALSE;
  117. TCHAR pszName[CREDUI_MAX_USERNAME_LENGTH+1] = {0};
  118. TCHAR pszPwd[CREDUI_MAX_PASSWORD_LENGTH+1] = {0};
  119. TCHAR pszDomain[CREDUI_MAX_USERNAME_LENGTH+1];
  120. TCHAR pszUserName[CREDUI_MAX_USERNAME_LENGTH+1];
  121. TCHAR pszAuthority[CREDUI_MAX_USERNAME_LENGTH+1];
  122. BOOL fSave;
  123. DWORD dwErr;
  124.  
  125. memset(&cui,0,sizeof(CREDUI_INFO));
  126. cui.cbSize = sizeof(CREDUI_INFO);
  127. cui.hwndParent = NULL;
  128. // Ensure that MessageText and CaptionText identify
  129. // what credentials to use and which application requires them.
  130. cui.pszMessageText = _T("Press cancel to use process token");
  131. cui.pszCaptionText = _T("Enter Account Information");
  132. cui.hbmBanner = NULL;
  133. fSave = FALSE;
  134.  
  135. dwErr = CredUIPromptForCredentials(
  136. &cui, // CREDUI_INFO structure
  137. _T(""), // Target for credentials
  138. NULL, // Reserved
  139. 0, // Reason
  140. pszName, // User name
  141. CREDUI_MAX_USERNAME_LENGTH+1, // Max number for user name
  142. pszPwd, // Password
  143. CREDUI_MAX_PASSWORD_LENGTH+1, // Max number for password
  144. &fSave, // State of save check box
  145. CREDUI_FLAGS_GENERIC_CREDENTIALS |// flags
  146. CREDUI_FLAGS_ALWAYS_SHOW_UI |
  147. CREDUI_FLAGS_DO_NOT_PERSIST);
  148.  
  149. if(dwErr == ERROR_CANCELLED)
  150. {
  151. useToken = true;
  152. }
  153. else if (dwErr)
  154. {
  155. cout << "Did not get credentials " << dwErr << endl;
  156. pLoc->Release();
  157. CoUninitialize();
  158. return 1;
  159. }
  160. */
  161.  
  162. // change the computerName strings below to the full computer name
  163. // of the remote computer
  164. CString strAuthority;
  165. if(!useNTLM)
  166. {
  167. //StringCchPrintf(pszAuthority, CREDUI_MAX_USERNAME_LENGTH+1, _T("kERBEROS:%s"), strComputerName);
  168. strAuthority = _T("kERBEROS:") + strComputerName;
  169.  
  170. }
  171.  
  172. // Connect to the remote rootcimv2 namespace
  173. // and obtain pointer pSvc to make IWbemServices calls.
  174. //---------------------------------------------------------
  175. CString strNetworkResource = _T("\\") + strComputerName + _T("\root\cimv2");
  176. if (strFullUsername == _T(""))
  177. {
  178. hres = pLoc->ConnectServer(
  179. _bstr_t(strNetworkResource),
  180. NULL, // User name
  181. NULL, // User password
  182. NULL, // Locale
  183. WBEM_FLAG_CONNECT_USE_MAX_WAIT, // Security flags
  184. _bstr_t(strAuthority), // Authority
  185. NULL, // Context object
  186. &pSvc // IWbemServices proxy
  187. );
  188. }
  189. else
  190. {
  191. hres = pLoc->ConnectServer(
  192. _bstr_t(strNetworkResource),
  193. _bstr_t(strFullUsername), // User name
  194. _bstr_t(strPassword), // User password
  195. NULL, // Locale
  196. WBEM_FLAG_CONNECT_USE_MAX_WAIT, // Security flags
  197. _bstr_t(strAuthority), // Authority
  198. NULL, // Context object
  199. &pSvc // IWbemServices proxy
  200. );
  201. }
  202.  
  203. if (FAILED(hres))
  204. {
  205. DWORD aaa = WIN32_FROM_HRESULT_alternate(hres);
  206. //cout << "Could not connect. Error code = 0x"
  207. // << hex << hres << endl;
  208.  
  209. pLoc->Release();
  210. CoUninitialize();
  211. MyMessageBox_Error(_T("connect"));
  212. return NULL; // Program has failed.
  213. }
  214.  
  215. //cout << "Connected to ROOT\CIMV2 WMI namespace" << endl;
  216.  
  217.  
  218. // step 5: --------------------------------------------------
  219. // Create COAUTHIDENTITY that can be used for setting security on proxy
  220.  
  221. COAUTHIDENTITY *userAcct = NULL;
  222. COAUTHIDENTITY authIdent;
  223.  
  224. if(!useToken)
  225. {
  226. memset(&authIdent, 0, sizeof(COAUTHIDENTITY));
  227. authIdent.PasswordLength = strPassword.GetLength();
  228. authIdent.Password = (USHORT*) _bstr_t(strPassword);
  229.  
  230.  
  231. authIdent.Domain = (USHORT*) _bstr_t(strDomainName);
  232. authIdent.DomainLength = strDomainName.GetLength();
  233. authIdent.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
  234.  
  235. userAcct = &authIdent;
  236.  
  237. }
  238.  
  239. // Step 6: --------------------------------------------------
  240. // Set security levels on a WMI connection ------------------
  241.  
  242. hres = CoSetProxyBlanket(
  243. pSvc, // Indicates the proxy to set
  244. RPC_C_AUTHN_DEFAULT, // RPC_C_AUTHN_xxx
  245. RPC_C_AUTHZ_DEFAULT, // RPC_C_AUTHZ_xxx
  246. COLE_DEFAULT_PRINCIPAL, // Server principal name
  247. RPC_C_AUTHN_LEVEL_PKT_PRIVACY, // RPC_C_AUTHN_LEVEL_xxx
  248. RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
  249. userAcct, // client identity
  250. EOAC_NONE // proxy capabilities
  251. );
  252.  
  253. if (FAILED(hres))
  254. {
  255. //cout << "Could not set proxy blanket. Error code = 0x"
  256. // << hex << hres << endl;
  257. pSvc->Release();
  258. pLoc->Release();
  259. CoUninitialize();
  260. MyMessageBox_Error(_T("connect"));
  261. return NULL; // Program has failed.
  262. }
  263.  
  264. // Cleanup
  265. // ========
  266. pLoc->Release();
  267.  
  268. return pSvc;
  269. }
  270.  
  271. vector<IWbemClassObject*> ADWMISearch::query(IWbemServices *pSvc, CString strDomainName, CString strPassword, CString strWQL)
  272. {
  273. vector<IWbemClassObject*> npResultObjects;
  274. BOOL useToken = TRUE;
  275. // step 5: --------------------------------------------------
  276. // Create COAUTHIDENTITY that can be used for setting security on proxy
  277.  
  278. COAUTHIDENTITY *userAcct = NULL;
  279. COAUTHIDENTITY authIdent;
  280.  
  281. if(!useToken)
  282. {
  283. memset(&authIdent, 0, sizeof(COAUTHIDENTITY));
  284. authIdent.PasswordLength = strPassword.GetLength();
  285. authIdent.Password = (USHORT*) _bstr_t(strPassword);
  286.  
  287. /*
  288. LPTSTR slash = _tcschr(pszName, _T('\'));
  289. if( slash == NULL )
  290. {
  291. //cout << _T("Could not create Auth identity. No domain specifiedn") ;
  292. pSvc->Release();
  293. pLoc->Release();
  294. CoUninitialize();
  295. return 1; // Program has failed.
  296. }
  297.  
  298. StringCchCopy(pszUserName, CREDUI_MAX_USERNAME_LENGTH+1, slash+1);
  299. authIdent.User = (USHORT*)pszUserName;
  300. authIdent.UserLength = _tcslen(pszUserName);
  301. StringCchCopyN(pszDomain, CREDUI_MAX_USERNAME_LENGTH+1, pszName, slash - pszName);
  302. */
  303.  
  304. authIdent.Domain = (USHORT*) _bstr_t(strDomainName);
  305. authIdent.DomainLength = strDomainName.GetLength();
  306. authIdent.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
  307.  
  308. userAcct = &authIdent;
  309.  
  310. }
  311.  
  312. // Step 7: --------------------------------------------------
  313. // Use the IWbemServices pointer to make requests of WMI ----
  314.  
  315. // For example, get the name of the operating system
  316. IEnumWbemClassObject* pEnumerator = NULL;
  317. HRESULT hResult;
  318. hResult = pSvc->ExecQuery(
  319. _bstr_t(_T("WQL")),
  320. _bstr_t(strWQL), //_T("Select * from Win32_Share")
  321. WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
  322. NULL,
  323. &pEnumerator);
  324.  
  325. if (FAILED(hResult))
  326. {
  327. //cout << "Query for operating system name failed."
  328. // << " Error code = 0x"
  329. // << hex << hres << endl;
  330. MyMessageBox_Error(_T("query"));
  331. return npResultObjects; // Program has failed.
  332. }
  333.  
  334. // Step 8: -------------------------------------------------
  335. // Secure the enumerator proxy
  336. hResult = CoSetProxyBlanket(
  337. pEnumerator, // Indicates the proxy to set
  338. RPC_C_AUTHN_DEFAULT, // RPC_C_AUTHN_xxx
  339. RPC_C_AUTHZ_DEFAULT, // RPC_C_AUTHZ_xxx
  340. COLE_DEFAULT_PRINCIPAL, // Server principal name
  341. RPC_C_AUTHN_LEVEL_PKT_PRIVACY, // RPC_C_AUTHN_LEVEL_xxx
  342. RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx
  343. userAcct, // client identity
  344. EOAC_NONE // proxy capabilities
  345. );
  346.  
  347. if (FAILED(hResult))
  348. {
  349. //cout << "Could not set proxy blanket on enumerator. Error code = 0x"
  350. // << hex << hres << endl;
  351. pEnumerator->Release();
  352. MyMessageBox_Error(_T("query"));
  353. return npResultObjects; // Program has failed.
  354. }
  355.  
  356. // When you have finished using the credentials,
  357. // erase them from memory.
  358.  
  359.  
  360.  
  361. // Step 9: -------------------------------------------------
  362. // Get the data from the query in step 7 -------------------
  363.  
  364. IWbemClassObject *pclsObj = NULL;
  365. ULONG uReturn = 0;
  366.  
  367. while (pEnumerator)
  368. {
  369. HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1,
  370. &pclsObj, &uReturn);
  371.  
  372. if(0 == uReturn)
  373. {
  374. break;
  375. }
  376.  
  377. npResultObjects.push_back(pclsObj);
  378. /*
  379. VARIANT vtProp;
  380.  
  381. // Get the value of the Name property
  382. hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0);
  383. cout << _T("OS Name: ") << vtProp.bstrVal << endl;
  384.  
  385. // Get the value of the FreePhysicalMemory property
  386. hr = pclsObj->Get(L"FreePhysicalMemory", 0, &vtProp, 0, 0);
  387. cout << "Free physical memory(in kilobytes): " << vtProp.uintVal << endl;
  388. VariantClear(&vtProp);
  389.  
  390. pclsObj->Release();
  391. pclsObj = NULL;
  392. */
  393. }
  394.  
  395. // Cleanup
  396. // ========
  397.  
  398. pEnumerator->Release();
  399.  
  400. return npResultObjects;
  401. }
  402.  
  403. CString ADWMISearch::getStringFromObject(IWbemClassObject* pObject, CString strPropertyName)
  404. {
  405. _bstr_t bstrPropertyName = strPropertyName;
  406.  
  407. VARIANT vtProperty;
  408. CString strProperty;
  409. // Get the value of the property
  410. VariantInit(&vtProperty);
  411. HRESULT hResult = pObject->Get(bstrPropertyName, 0, &vtProperty, 0, 0);
  412. if (SUCCEEDED(hResult) && V_VT(&vtProperty) == VT_BSTR)
  413. {
  414. strProperty = vtProperty.bstrVal;
  415. VariantClear(&vtProperty);
  416. return strProperty;
  417. }
  418. else
  419. {
  420. VariantClear(&vtProperty);
  421. MyMessageBox_Error(_T("getStringsFromObjects"));
  422. return _T("");
  423. }
  424. }
  425.  
  426. vector<CString> ADWMISearch::getStringsFromObjects(vector<IWbemClassObject*> npObjects, CString strPropertyName)
  427. {
  428. _bstr_t bstrPropertyName = strPropertyName;
  429. vector<CString> nstrProperties;
  430.  
  431. for (int i = 0; i < npObjects.size(); i ++)
  432. {
  433. VARIANT vtProperty;
  434. CString strProperty;
  435. // Get the value of the property
  436. VariantInit(&vtProperty);
  437. HRESULT hResult = npObjects[i]->Get(bstrPropertyName, 0, &vtProperty, 0, 0);
  438. if (SUCCEEDED(hResult) && V_VT(&vtProperty) == VT_BSTR)
  439. {
  440. CString strProperty = vtProperty.bstrVal;
  441. nstrProperties.push_back(strProperty);
  442. VariantClear(&vtProperty);
  443. }
  444. else
  445. {
  446. VariantClear(&vtProperty);
  447. MyMessageBox_Error(_T("getStringsFromObjects"));
  448. return nstrProperties;
  449. }
  450. }
  451. return nstrProperties;
  452. }
  453.  
  454. void ADWMISearch::clearObjects(vector<IWbemClassObject*> npObjects)
  455. {
  456. for (int i = 0; i < npObjects.size(); i ++)
  457. {
  458. npObjects[i]->Release();
  459. npObjects[i] = NULL;
  460. }
  461. npObjects.clear();
  462. }
  463.  
  464. IWbemClassObject* ADWMISearch::getWMIClass(IWbemServices *pSvc, CString strClassName)
  465. {
  466. HRESULT hResult;
  467. IWbemClassObject* pClass = NULL;
  468. hResult = pSvc->GetObject(_bstr_t(strClassName), 0, NULL, &pClass, NULL); //_T("Win32_Share")
  469. if (!SUCCEEDED(hResult))
  470. {
  471. MyMessageBox_Error(_T("getWMIClass"));
  472. return NULL;
  473. }
  474. else
  475. {
  476. return pClass;
  477. }
  478. }
  479.  
  480. IWbemClassObject* ADWMISearch::getObjectFromObject(IWbemClassObject *pObject, CString strArgumentName)
  481. {
  482. if (!pObject)
  483. {
  484. MyMessageBox_Error(_T("getObjectFromObject"));
  485. return NULL;
  486. }
  487.  
  488. HRESULT hResult;
  489. VARIANT varArgument;
  490.  
  491. hResult = pObject->Get(_bstr_t(strArgumentName), 0, &varArgument, NULL, 0);
  492. if (!SUCCEEDED(hResult))
  493. {
  494. VariantClear(&varArgument);
  495. MyMessageBox_Error(_T("getObjectFromObject"));
  496. return NULL;
  497. }
  498.  
  499. //IWbemClassObject **ppResultObject;
  500. IWbemClassObject *pResultObject2;
  501. if (V_VT(&varArgument) == VT_UNKNOWN)
  502. {
  503. //ppResultObject = (IWbemClassObject **)varArgument.ppunkVal;
  504. pResultObject2 = (IWbemClassObject *)varArgument.punkVal;
  505. }
  506. else if (V_VT(&varArgument) == VT_DISPATCH)
  507. {
  508. //ppResultObject = (IWbemClassObject **)varArgument.ppdispVal;
  509. pResultObject2 = (IWbemClassObject *)varArgument.pdispVal;
  510. }
  511. else
  512. {
  513. VariantClear(&varArgument);
  514. MyMessageBox_Error(_T("getObjectFromObject"));
  515. return NULL;
  516. }
  517.  
  518. VariantClear(&varArgument);
  519.  
  520. //IWbemClassObject *pResultObject = *ppResultObject;
  521. //return pResultObject;
  522. return pResultObject2;
  523. }
  524.  
  525. IWbemClassObject* ADWMISearch::getObjectFromObjectWithCheck(IWbemClassObject *pOutParams, CString strArgumentName)
  526. {
  527. if (!pOutParams)
  528. {
  529. MyMessageBox_Error(_T("getObjectFromObjectWithCheck"));
  530. return NULL;
  531. }
  532.  
  533. HRESULT hResult;
  534. VARIANT varReturnValue;
  535. VARIANT varArgument;
  536. hResult = pOutParams->Get(_bstr_t(L"ReturnValue"), 0, &varReturnValue, NULL, 0);
  537. if (!SUCCEEDED(hResult))
  538. {
  539. VariantClear(&varReturnValue);
  540. VariantClear(&varArgument);
  541. MyMessageBox_Error(_T("getObjectFromObjectWithCheck"));
  542. return NULL;
  543. }
  544. DWORD dwResult = varReturnValue.lVal;
  545.  
  546. hResult = pOutParams->Get(_bstr_t(strArgumentName), 0, &varArgument, NULL, 0);
  547. if (!SUCCEEDED(hResult))
  548. {
  549. VariantClear(&varReturnValue);
  550. VariantClear(&varArgument);
  551. MyMessageBox_Error(_T("getObjectFromObjectWithCheck"));
  552. return NULL;
  553. }
  554.  
  555. //IWbemClassObject **ppResultObject;
  556. IWbemClassObject *pResultObject2;
  557. if (V_VT(&varArgument) == VT_UNKNOWN)
  558. {
  559. //ppResultObject = (IWbemClassObject **)varArgument.ppunkVal;
  560. pResultObject2 = (IWbemClassObject *)varArgument.punkVal;
  561. }
  562. else if (V_VT(&varArgument) == VT_DISPATCH)
  563. {
  564. //ppResultObject = (IWbemClassObject **)varArgument.ppdispVal;
  565. pResultObject2 = (IWbemClassObject *)varArgument.pdispVal;
  566. }
  567. else
  568. {
  569. VariantClear(&varReturnValue);
  570. VariantClear(&varArgument);
  571. MyMessageBox_Error(_T("getObjectFromObjectWithCheck"));
  572. return NULL;
  573. }
  574.  
  575. VariantClear(&varReturnValue);
  576. VariantClear(&varArgument);
  577.  
  578. //IWbemClassObject *pResultObject = *ppResultObject;
  579. //return pResultObject;
  580. return pResultObject2;
  581. }
  582.  
  583. vector<ADWMIParam> ADWMISearch::genObjectArguments(CString strArgName, IWbemClassObject *pObject)
  584. {
  585. vector<ADWMIParam> resultArgs;
  586. resultArgs.push_back(ADWMIParam(strArgName, pObject));
  587. return resultArgs;
  588. }
  589.  
  590. IWbemClassObject* ADWMISearch::callStaticMethod(IWbemServices *pSvc, IWbemClassObject *pClass, CString strClassName,
  591. CString strMethodName)
  592. {
  593. return callStaticMethod(pSvc, pClass, strClassName, strMethodName, vector<ADWMIParam>());
  594. }
  595.  
  596. IWbemClassObject* ADWMISearch::callStaticMethod(IWbemServices *pSvc, IWbemClassObject *pClass, CString strClassName,
  597. CString strMethodName, vector<ADWMIParam> &arguments)
  598. {
  599. _bstr_t bstrClassName = _bstr_t(strClassName);
  600. _bstr_t bstrMethodName = _bstr_t(strMethodName);
  601. BOOL bInParams;
  602. BOOL bOutParams;
  603.  
  604. HRESULT hResult;
  605. IWbemClassObject* pClass2 = getWMIClass(pSvc, strClassName);
  606.  
  607. IWbemClassObject* pInParamsDefinition = NULL;
  608. IWbemClassObject* pOutParamsDefinition = NULL;
  609. hResult = pClass2->GetMethod(bstrMethodName, 0, &pInParamsDefinition, &pOutParamsDefinition);
  610. if (hResult != WBEM_S_NO_ERROR)
  611. {
  612. //pClass->Release();
  613. MyMessageBox_Error(_T("callStaticMethod"));
  614. return NULL;
  615. }
  616. if (pInParamsDefinition == NULL)
  617. {
  618. bInParams = FALSE;
  619. }
  620. else
  621. {
  622. bInParams = TRUE;
  623. }
  624. if (pOutParamsDefinition == NULL)
  625. {
  626. bOutParams = FALSE;
  627. }
  628. else
  629. {
  630. bOutParams = TRUE;
  631. }
  632.  
  633. IWbemClassObject* pInParamsInstance = NULL;
  634. if (bInParams)
  635. {
  636. hResult = pInParamsDefinition->SpawnInstance(0, &pInParamsInstance);
  637.  
  638. for (int i = 0; i < arguments.size(); i ++)
  639. {
  640. _variant_t varArg;
  641. VariantCopy(&varArg, &(arguments[i].value));
  642. hResult = pInParamsInstance->Put(_bstr_t(arguments[i].key), 0, &varArg, 0);
  643. //hResult = pInParamsInstance->Put(_bstr_t(arguments[i].key), 0, &(arguments[i].value), 0);
  644. }
  645. }
  646.  
  647. IWbemClassObject* pOutParams = NULL;
  648. hResult = pSvc->ExecMethod(bstrClassName, bstrMethodName, 0, NULL, pInParamsInstance, &pOutParams, NULL);
  649. if (hResult != WBEM_S_NO_ERROR)
  650. {
  651. //pClass->Release();
  652. if (pInParamsDefinition != NULL)
  653. {
  654. pInParamsDefinition->Release();
  655. }
  656. if (pOutParamsDefinition != NULL)
  657. {
  658. pOutParamsDefinition->Release();
  659. }
  660. if (pInParamsInstance != NULL)
  661. {
  662. pInParamsInstance->Release();
  663. }
  664. MyMessageBox_Error(_T("callStaticMethod"));
  665. return NULL;
  666. }
  667.  
  668. if (pInParamsDefinition != NULL)
  669. {
  670. pInParamsDefinition->Release();
  671. }
  672. if (pOutParamsDefinition != NULL)
  673. {
  674. pOutParamsDefinition->Release();
  675. }
  676. if (pInParamsInstance != NULL)
  677. {
  678. pInParamsInstance->Release();
  679. }
  680.  
  681. if (bOutParams)
  682. {
  683. return pOutParams;
  684. }
  685. else
  686. {
  687. return NULL;
  688. }
  689. }
  690.  
  691. IWbemClassObject* ADWMISearch::callMethod(IWbemServices *pSvc, IWbemClassObject *pClass, CString strClassName,
  692. CString strInstancePath, CString strMethodName)
  693. {
  694. return callMethod(pSvc, pClass, strClassName, strInstancePath, strMethodName, vector<ADWMIParam>());
  695. }
  696.  
  697. IWbemClassObject* ADWMISearch::callMethod(IWbemServices *pSvc, IWbemClassObject *pClass, CString strClassName,
  698. CString strInstancePath, CString strMethodName, vector<ADWMIParam> &arguments)
  699. {
  700. _bstr_t bstrClassName = _bstr_t(strClassName);
  701. _bstr_t bstrMethodName = _bstr_t(strMethodName);
  702. BOOL bInParams;
  703. BOOL bOutParams;
  704.  
  705. HRESULT hResult;
  706. //IWbemClassObject* pClass = getWMIClass(pSvc, strClassName);
  707.  
  708. IWbemClassObject* pInParamsDefinition = NULL;
  709. IWbemClassObject* pOutParamsDefinition = NULL;
  710. hResult = pClass->GetMethod(bstrMethodName, 0, &pInParamsDefinition, &pOutParamsDefinition);
  711. if (hResult != WBEM_S_NO_ERROR)
  712. {
  713. //pClass->Release();
  714. MyMessageBox_Error(_T("callMethod"));
  715. return NULL;
  716. }
  717. if (pInParamsDefinition == NULL)
  718. {
  719. bInParams = FALSE;
  720. }
  721. else
  722. {
  723. bInParams = TRUE;
  724. }
  725. if (pOutParamsDefinition == NULL)
  726. {
  727. bOutParams = FALSE;
  728. }
  729. else
  730. {
  731. bOutParams = TRUE;
  732. }
  733.  
  734. IWbemClassObject* pInParamsInstance = NULL;
  735. if (bInParams)
  736. {
  737. hResult = pInParamsDefinition->SpawnInstance(0, &pInParamsInstance);
  738.  
  739. for (int i = 0; i < arguments.size(); i ++)
  740. {
  741. _variant_t varArg;
  742. VariantCopy(&varArg, &(arguments[i].value));
  743. hResult = pInParamsInstance->Put(_bstr_t(arguments[i].key), 0, &varArg, 0);
  744. //hResult = pInParamsInstance->Put(_bstr_t(arguments[i].key), 0, &(arguments[i].value), 0);
  745. }
  746. }
  747.  
  748. IWbemClassObject* pOutParams = NULL;
  749. hResult = pSvc->ExecMethod(_bstr_t(strInstancePath), bstrMethodName, 0, NULL, pInParamsInstance, &pOutParams, NULL);
  750. if (hResult != WBEM_S_NO_ERROR)
  751. {
  752. //pClass->Release();
  753. if (pInParamsDefinition != NULL)
  754. {
  755. pInParamsDefinition->Release();
  756. }
  757. if (pOutParamsDefinition != NULL)
  758. {
  759. pOutParamsDefinition->Release();
  760. }
  761. if (pInParamsInstance != NULL)
  762. {
  763. pInParamsInstance->Release();
  764. }
  765. MyMessageBox_Error(_T("callMethod"));
  766. return NULL;
  767. }
  768.  
  769. if (pInParamsDefinition != NULL)
  770. {
  771. pInParamsDefinition->Release();
  772. }
  773. if (pOutParamsDefinition != NULL)
  774. {
  775. pOutParamsDefinition->Release();
  776. }
  777. if (pInParamsInstance != NULL)
  778. {
  779. pInParamsInstance->Release();
  780. }
  781.  
  782. if (bOutParams)
  783. {
  784. return pOutParams;
  785. }
  786. else
  787. {
  788. return NULL;
  789. }
  790. }
  791.  
  792. void ADWMISearch::disconnect(IWbemServices *pSvc)
  793. {
  794. pSvc->Release();
  795. CoUninitialize();
  796. }
  797.  
  798. #include <Wbemidl.h>
  799.  
  800. #include <vector>
  801. #include <map>
  802. using namespace std;
  803.  
  804. class ADWMIParam
  805. {
  806. public:
  807. CString key;
  808. _variant_t value;
  809. public:
  810. ADWMIParam(CString strKey, CString strValue)
  811. {
  812. key = strKey;
  813. VariantInit(&value);
  814. value.vt = VT_BSTR;
  815. value.bstrVal = _bstr_t(strValue);
  816. }
  817. ADWMIParam(CString strKey, IWbemClassObject *pValue)
  818. {
  819. key = strKey;
  820. VariantInit(&value);
  821. value.vt = VT_UNKNOWN;
  822. value.punkVal = pValue;
  823. }
  824. };
  825.  
  826. class ADWMISearch
  827. {
  828. public:
  829. DWORD WIN32_FROM_HRESULT_alternate(HRESULT hr);
  830. IWbemServices* connect(CString strServerName, CString strServerIP, CString strDomainName,
  831. CString strUsername, CString strPassword);
  832. vector<IWbemClassObject*> query(IWbemServices *pSvc, CString strDomainName, CString strPassword, CString strWQL);
  833. CString getStringFromObject(IWbemClassObject* pObject, CString strPropertyName);
  834. vector<CString> getStringsFromObjects(vector<IWbemClassObject*> npObjects, CString strPropertyName);
  835. void clearObjects(vector<IWbemClassObject*> npObjects);
  836. IWbemClassObject* getWMIClass(IWbemServices *pSvc, CString strClassName);
  837. IWbemClassObject* getObjectFromObject(IWbemClassObject *pObject, CString strArgumentName);
  838. IWbemClassObject* getObjectFromObjectWithCheck(IWbemClassObject *pOutParams, CString strArgumentName);
  839. vector<ADWMIParam> genObjectArguments(CString strArgName, IWbemClassObject *pObject);
  840. IWbemClassObject* callStaticMethod(IWbemServices *pSvc, IWbemClassObject *pClass, CString strClassName,
  841. CString strMethodName);
  842. IWbemClassObject* callStaticMethod(IWbemServices *pSvc, IWbemClassObject *pClass, CString strClassName,
  843. CString strMethodName, vector<ADWMIParam> &arguments);
  844. IWbemClassObject* callMethod(IWbemServices *pSvc, IWbemClassObject *pClass, CString strClassName,
  845. CString strInstancePath, CString strMethodName);
  846. IWbemClassObject* callMethod(IWbemServices *pSvc, IWbemClassObject *pClass, CString strClassName,
  847. CString strInstancePath, CString strMethodName, vector<ADWMIParam> &arguments);
  848. void disconnect(IWbemServices *pSvc);
  849. };
  850.  
  851. ADWMISearch *wmiSearcher = new ADWMISearch();
  852. IWbemServices *pSvc = wmiSearcher->connect("luo-pc", "127.0.0.1", "", "", "");
  853. IWbemClassObject *pLSSSClass = wmiSearcher->getWMIClass(pSvc, "Win32_LogicalShareSecuritySetting");
  854.  
  855. vector<IWbemClassObject*> npObjects = wmiSearcher->query(pSvc, "", "", "Select * from Win32_Log
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!