Dela via

Exempel: Hämta WMI-data från en fjärrdator

Du kan använda proceduren och kodexemplen i det här avsnittet för att skapa ett fullständigt WMI-klientprogram som utför COM-initiering, ansluter till WMI på en fjärrdator, hämtar data semisynkront och sedan rensar upp. Mer information om hur du hämtar data från den lokala datorn finns i Exempel: Hämta WMI-data från den lokala datorn. Mer information om hur du hämtar data asynkront finns i Exempel: Hämta WMI-data från den lokala datorn asynkront.

Not

Om du försöker ansluta till en fjärrdator kan du läsa informationen i Ansluta till WMI via fjärranslutning.

 

Följande procedur visar hur du kör WMI-programmet. Steg 1 till och med 5 innehåller alla steg som krävs för att konfigurera och ansluta till WMI, och steg 6 och 7 är där data efterfrågas och tas emot.

Hämta WMI-data från en fjärrdator

  1. Initiera COM-parametrar med ett anrop till CoInitializeEx.

    Mer information finns i Initiera COM för ett WMI-program.

  2. Initiera COM-processsäkerhet genom att anropa CoInitializeSecurity.

    Mer information finns i Ange standardprocesssäkerhetsnivå med C++.

  3. Hämta den första lokaliseraren till WMI genom att anropa CoCreateInstance.

    Mer information finns i Skapa en anslutning till ett WMI-namnområde.

  4. Hämta en pekare till IWbemServices för namnområdet \\root\cimv2 på en fjärrdator genom att anropa IWbemLocator::ConnectServer. När du ansluter till en fjärrdator måste du känna till datornamnet, domänen, användarnamnet och lösenordet för fjärrdatorn som du ansluter till. Alla dessa attribut skickas till metoden IWbemLocator::ConnectServer. Kontrollera också att användarnamnet på den dator som försöker ansluta till fjärrdatorn har rätt åtkomstbehörighet på fjärrdatorn. Mer information finns i Ansluta via Windows-brandväggen. Information om hur du ansluter till den lokala datorn finns i Exempel: Hämta WMI-data från den lokala datorn och Skapa en anslutning till ett WMI-namnområde.

    När du hanterar användarnamn och lösenord rekommenderar vi att användaren uppmanas att ange informationen, använda informationen och sedan ta bort informationen, så att det är mindre risk att informationen fångas upp av en obehörig användare. Steg 4 i exempelkoden nedan använder CredUIPromptForCredentials för att hämta användarnamnet och lösenordet och använder sedan SecureZeroMemory för att bli av med informationen när den har använts i IWbemLocator::ConnectServer. Mer information finns i Hantera lösenord och Fråga användaren om autentiseringsuppgifter.

  5. Skapa en COAUTHIDENTITY- struktur för att ange autentiseringsuppgifter för att ange proxysäkerhet.

  6. Ange IWbemServices proxysäkerhet så att WMI-tjänsten kan personifiera klienten genom att anropa CoSetProxyBlanket.

    Mer information finns i Ställa in säkerhetsnivåerna för en WMI-anslutning.

  7. Använd pekaren IWbemServices för att göra begäranden om WMI. En fråga körs för att hämta namnet på operativsystemet och mängden ledigt fysiskt minne genom att anropa IWbemServices::ExecQuery.

    Följande WQL-fråga är ett av metodargumenten.

    SELECT * FROM Win32_OperatingSystem

    Resultatet av den här frågan lagras i en IEnumWbemClassObject- pekare. På så sätt kan dataobjekten från frågan hämtas semisynkront med gränssnittet IEnumWbemClassObject. Mer information finns i Räkna upp WMI-. Information om hur du hämtar data asynkront finns i Exempel: Hämta WMI-data från den lokala datorn asynkront.

    Mer information om hur du gör begäranden om WMI finns i Ändra klass- och instansinformation, Fråga WMIoch Anropa en metod.

  8. Ange IEnumWbemClassObject uppräkningsproxysäkerhet. Se till att radera autentiseringsuppgifterna från minnet när du har använt dem.

    Mer information finns i Ställa in säkerhet på IWbemServices och andra proxyservrar.

  9. Hämta och visa data från WQL-frågan. Pekaren IEnumWbemClassObject är länkad till dataobjekten som frågan returnerade, och dataobjekten kan hämtas med IEnumWbemClassObject::Nästa metod. Den här metoden länkar dataobjekten till en IWbemClassObject pekare som skickas till metoden. Använd metoden IWbemClassObject::Get för att hämta önskad information från dataobjekten.

    Följande kodexempel används för att hämta egenskapen Name från dataobjektet, som innehåller namnet på operativsystemet.

    VARIANT vtProp;

// Get the value of the Name property
hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0);
wcout << " OS Name : " << vtProp.bstrVal << endl;

    När värdet för egenskapen Name lagras i variabeln VARIANTvtPropkan den sedan visas för användaren.

    I följande kodexempel visas hur variabeln VARIANT kan användas igen för att lagra och visa värdet för mängden ledigt fysiskt minne.

    hr = pclsObj->Get(L"FreePhysicalMemory",
    0, &vtProp, 0, 0);
wcout << " Free physical memory (in kilobytes): "
    << vtProp.uintVal << endl;

    Mer information finns i Räkna upp WMI-.

Följande kodexempel visar hur du hämtar WMI-data semisynkront från en fjärrdator.

#define _WIN32_DCOM
#define UNICODE
#include <iostream>
using namespace std;
#include <comdef.h>
#include <Wbemidl.h>
#pragma comment(lib, "wbemuuid.lib")
#pragma comment(lib, "credui.lib")
#pragma comment(lib, "comsuppw.lib")
#include <wincred.h>
#include <strsafe.h>

int __cdecl main(int argc, char **argv)
{
    HRESULT hres;

    // Step 1: --------------------------------------------------
    // Initialize COM. ------------------------------------------

    hres =  CoInitializeEx(0, COINIT_MULTITHREADED); 
    if (FAILED(hres))
    {
        cout << "Failed to initialize COM library. Error code = 0x" 
            << hex << hres << endl;
        return 1;                  // Program has failed.
    }

    // Step 2: --------------------------------------------------
    // Set general COM security levels --------------------------

    hres =  CoInitializeSecurity(
        NULL, 
        -1,                          // COM authentication
        NULL,                        // Authentication services
        NULL,                        // Reserved
        RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication 
        RPC_C_IMP_LEVEL_IDENTIFY,    // Default Impersonation  
        NULL,                        // Authentication info
        EOAC_NONE,                   // Additional capabilities 
        NULL                         // Reserved
        );

                      
    if (FAILED(hres))
    {
        cout << "Failed to initialize security. Error code = 0x" 
            << hex << hres << endl;
        CoUninitialize();
        return 1;                    // Program has failed.
    }
    
    // Step 3: ---------------------------------------------------
    // Obtain the initial locator to WMI -------------------------

    IWbemLocator *pLoc = NULL;

    hres = CoCreateInstance(
        CLSID_WbemLocator,             
        0, 
        CLSCTX_INPROC_SERVER, 
        IID_IWbemLocator, (LPVOID *) &pLoc);
 
    if (FAILED(hres))
    {
        cout << "Failed to create IWbemLocator object."
            << " Err code = 0x"
            << hex << hres << endl;
        CoUninitialize();
        return 1;                 // Program has failed.
    }

    // Step 4: -----------------------------------------------------
    // Connect to WMI through the IWbemLocator::ConnectServer method

    IWbemServices *pSvc = NULL;

    // Get the user name and password for the remote computer
    CREDUI_INFO cui;
    bool useToken = false;
    bool useNTLM = true;
    wchar_t pszName[CREDUI_MAX_USERNAME_LENGTH+1] = {0};
    wchar_t pszPwd[CREDUI_MAX_PASSWORD_LENGTH+1] = {0};
    wchar_t pszDomain[CREDUI_MAX_USERNAME_LENGTH+1];
    wchar_t pszUserName[CREDUI_MAX_USERNAME_LENGTH+1];
    wchar_t pszAuthority[CREDUI_MAX_USERNAME_LENGTH+1];
    BOOL fSave;
    DWORD dwErr;

    memset(&cui,0,sizeof(CREDUI_INFO));
    cui.cbSize = sizeof(CREDUI_INFO);
    cui.hwndParent = NULL;
    // Ensure that MessageText and CaptionText identify
    // what credentials to use and which application requires them.
    cui.pszMessageText = TEXT("Press cancel to use process token");
    cui.pszCaptionText = TEXT("Enter Account Information");
    cui.hbmBanner = NULL;
    fSave = FALSE;

    dwErr = CredUIPromptForCredentials( 
        &cui,                             // CREDUI_INFO structure
        TEXT(""),                         // Target for credentials
        NULL,                             // Reserved
        0,                                // Reason
        pszName,                          // User name
        CREDUI_MAX_USERNAME_LENGTH+1,     // Max number for user name
        pszPwd,                           // Password
        CREDUI_MAX_PASSWORD_LENGTH+1,     // Max number for password
        &fSave,                           // State of save check box
        CREDUI_FLAGS_GENERIC_CREDENTIALS |// flags
        CREDUI_FLAGS_ALWAYS_SHOW_UI |
        CREDUI_FLAGS_DO_NOT_PERSIST);  

    if(dwErr == ERROR_CANCELLED)
    {
        useToken = true;
    }
    else if (dwErr)
    {
        cout << "Did not get credentials " << dwErr << endl;
        pLoc->Release();     
        CoUninitialize();
        return 1;      
    }

    // change the computerName strings below to the full computer name
    // of the remote computer
    if(!useNTLM)
    {
        StringCchPrintf(pszAuthority, CREDUI_MAX_USERNAME_LENGTH+1, L"kERBEROS:%s", L"COMPUTERNAME");
    }

    // Connect to the remote root\cimv2 namespace
    // and obtain pointer pSvc to make IWbemServices calls.
    //---------------------------------------------------------
   
    hres = pLoc->ConnectServer(
        _bstr_t(L"\\\\COMPUTERNAME\\root\\cimv2"),
        _bstr_t(useToken?NULL:pszName),    // User name
        _bstr_t(useToken?NULL:pszPwd),     // User password
        NULL,                              // Locale             
        NULL,                              // Security flags
        _bstr_t(useNTLM?NULL:pszAuthority),// Authority        
        NULL,                              // Context object 
        &pSvc                              // IWbemServices proxy
        );
    
    if (FAILED(hres))
    {
        cout << "Could not connect. Error code = 0x" 
             << hex << hres << endl;
        pLoc->Release();     
        CoUninitialize();
        return 1;                // Program has failed.
    }

    cout << "Connected to ROOT\\CIMV2 WMI namespace" << endl;


    // step 5: --------------------------------------------------
    // Create COAUTHIDENTITY that can be used for setting security on proxy

    COAUTHIDENTITY *userAcct =  NULL ;
    COAUTHIDENTITY authIdent;

    if( !useToken )
    {
        memset(&authIdent, 0, sizeof(COAUTHIDENTITY));
        authIdent.PasswordLength = wcslen (pszPwd);
        authIdent.Password = (USHORT*)pszPwd;

        LPWSTR slash = wcschr (pszName, L'\\');
        if( slash == NULL )
        {
            cout << "Could not create Auth identity. No domain specified\n" ;
            pSvc->Release();
            pLoc->Release();     
            CoUninitialize();
            return 1;               // Program has failed.
        }

        StringCchCopy(pszUserName, CREDUI_MAX_USERNAME_LENGTH+1, slash+1);
        authIdent.User = (USHORT*)pszUserName;
        authIdent.UserLength = wcslen(pszUserName);

        StringCchCopyN(pszDomain, CREDUI_MAX_USERNAME_LENGTH+1, pszName, slash - pszName);
        authIdent.Domain = (USHORT*)pszDomain;
        authIdent.DomainLength = slash - pszName;
        authIdent.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;

        userAcct = &authIdent;

    }

    // Step 6: --------------------------------------------------
    // Set security levels on a WMI connection ------------------

    hres = CoSetProxyBlanket(
       pSvc,                           // Indicates the proxy to set
       RPC_C_AUTHN_DEFAULT,            // RPC_C_AUTHN_xxx
       RPC_C_AUTHZ_DEFAULT,            // RPC_C_AUTHZ_xxx
       COLE_DEFAULT_PRINCIPAL,         // Server principal name 
       RPC_C_AUTHN_LEVEL_PKT_PRIVACY,  // RPC_C_AUTHN_LEVEL_xxx 
       RPC_C_IMP_LEVEL_IMPERSONATE,    // RPC_C_IMP_LEVEL_xxx
       userAcct,                       // client identity
       EOAC_NONE                       // proxy capabilities 
    );

    if (FAILED(hres))
    {
        cout << "Could not set proxy blanket. Error code = 0x" 
            << hex << hres << endl;
        pSvc->Release();
        pLoc->Release();     
        CoUninitialize();
        return 1;               // Program has failed.
    }

    // Step 7: --------------------------------------------------
    // Use the IWbemServices pointer to make requests of WMI ----

    // For example, get the name of the operating system
    IEnumWbemClassObject* pEnumerator = NULL;
    hres = pSvc->ExecQuery(
        bstr_t("WQL"), 
        bstr_t("Select * from Win32_OperatingSystem"),
        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, 
        NULL,
        &pEnumerator);
    
    if (FAILED(hres))
    {
        cout << "Query for operating system name failed."
            << " Error code = 0x" 
            << hex << hres << endl;
        pSvc->Release();
        pLoc->Release();
        CoUninitialize();
        return 1;               // Program has failed.
    }

    // Step 8: -------------------------------------------------
    // Secure the enumerator proxy
    hres = CoSetProxyBlanket(
        pEnumerator,                    // Indicates the proxy to set
        RPC_C_AUTHN_DEFAULT,            // RPC_C_AUTHN_xxx
        RPC_C_AUTHZ_DEFAULT,            // RPC_C_AUTHZ_xxx
        COLE_DEFAULT_PRINCIPAL,         // Server principal name 
        RPC_C_AUTHN_LEVEL_PKT_PRIVACY,  // RPC_C_AUTHN_LEVEL_xxx 
        RPC_C_IMP_LEVEL_IMPERSONATE,    // RPC_C_IMP_LEVEL_xxx
        userAcct,                       // client identity
        EOAC_NONE                       // proxy capabilities 
        );

    if (FAILED(hres))
    {
        cout << "Could not set proxy blanket on enumerator. Error code = 0x" 
             << hex << hres << endl;
        pEnumerator->Release();
        pSvc->Release();
        pLoc->Release();     
        CoUninitialize();
        return 1;               // Program has failed.
    }

    // When you have finished using the credentials,
    // erase them from memory.
    SecureZeroMemory(pszName, sizeof(pszName));
    SecureZeroMemory(pszPwd, sizeof(pszPwd));
    SecureZeroMemory(pszUserName, sizeof(pszUserName));
    SecureZeroMemory(pszDomain, sizeof(pszDomain));


    // Step 9: -------------------------------------------------
    // Get the data from the query in step 7 -------------------
 
    IWbemClassObject *pclsObj = NULL;
    ULONG uReturn = 0;
   
    while (pEnumerator)
    {
        HRESULT hr = pEnumerator->Next(WBEM_INFINITE, 1, 
            &pclsObj, &uReturn);

        if(0 == uReturn)
        {
            break;
        }

        VARIANT vtProp;

        // Get the value of the Name property
        hr = pclsObj->Get(L"Name", 0, &vtProp, 0, 0);
        wcout << " OS Name : " << vtProp.bstrVal << endl;

        // Get the value of the FreePhysicalMemory property
        hr = pclsObj->Get(L"FreePhysicalMemory",
            0, &vtProp, 0, 0);
        wcout << " Free physical memory (in kilobytes): "
            << vtProp.uintVal << endl;
        VariantClear(&vtProp);

        pclsObj->Release();
        pclsObj = NULL;
    }

    // Cleanup
    // ========
    
    pSvc->Release();
    pLoc->Release();
    pEnumerator->Release();
    if( pclsObj )
    {
        pclsObj->Release();
    }
    
    CoUninitialize();

    return 0;   // Program successfully completed.
    
}