WmiDumper.cpp

Go to the documentation of this file.

/* 
 * Confdump-Agent - Dump static and runtime system configuration
 * Copyright (C) 2009-2012  Straton IT, SAS
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <comdef.h>
#include <Wbemidl.h>

#include <algorithm>

#include "boost/foreach.hpp"

#include "QVariant"
#include "QList"
#include "QString"

#include "Confdump/System/WmiDumper.hpp"
#include "Confdump/System/ManagedElement.hpp"
#include "Confdump/System/Wmi/ComContext.hpp"
#include "Confdump/System/Wmi/WbemServices.hpp"
#include "Confdump/System/Wmi/errors.hpp"

using namespace Confdump::System::Wmi;
using boost::shared_ptr;

/* Design notes: the "iterate over WMI Object properties" and "iterate over
 * SafeArray elements" parts could easily be abstracted as custom iterators.
 * However, they are unlikely to need much maintenance in the future so it
 * seems like an useless investment right now.
 *
 * -T. Equeter, 2011-09.
 */

namespace
{

QVariant bstrToQVariant( _bstr_t str )
{
        return QString::fromWCharArray( str, str.length() );
}

QVariant variantToQVariant( _variant_t value )
{
        if ( V_VT( &value ) & VT_ARRAY )
        {
                try {
                        value.ChangeType( VT_ARRAY|VT_BSTR );
                }
                catch( _com_error& )
                {
                        return QVariant();
                }
                
                HRESULT hr;
                SAFEARRAY *arr = V_ARRAY(&value); // variant still owns the array

                LONG lStart = 0;
                hr = SafeArrayGetLBound(arr, 1, &lStart);
                throwOnComError( hr, "get the lower bound of a WMI object array attribute" );

                LONG lEnd = 0;
                hr = SafeArrayGetUBound(arr, 1, &lEnd);
                throwOnComError( hr, "get the upper bound of a WMI object array attribute" );

                BSTR HUGEP *elements;
                hr = SafeArrayAccessData( arr, reinterpret_cast<void HUGEP**>( &elements ) );
                throwOnComError( hr, "access a WMI object array attribute" );
                shared_ptr<SAFEARRAY> arrayAccessGuard( arr, SafeArrayUnaccessData );
                
                QList<QVariant> qlist;
                std::transform( &elements[lStart], &elements[lEnd+1], std::back_inserter( qlist ), bstrToQVariant );

        return qlist;
    }
    else // if ( valueType != VT_NULL && valueType != VT_EMPTY )
    {
                try {
                        _bstr_t str = value;
                        return QString::fromWCharArray( str, str.length() );
                }
                catch( _com_error& )
                {
                        return QVariant();
                }
        }
}

} // ns


Confdump::System::WmiDumper::WmiDumper()
{
    initWbemServices();
    services_->connect();
}

Confdump::System::WmiDumper::WmiDumper( QString wmiNamespace )
{
    initWbemServices();
    services_->setWmiNamespace( wmiNamespace );
    services_->connect();
}

Confdump::System::WmiDumper::~WmiDumper()
{
}

void Confdump::System::WmiDumper::initWbemServices()
{
        ComContext::Guard guard = ComContext().getGuard();
    services_.reset( new Wmi::WbemServices( guard ) );
}

Confdump::Result Confdump::System::WmiDumper::doQueryTable( QString table )
{
    Result result;
    HRESULT hr;

        Query query("*", table.toStdString(), "");
    BOOST_FOREACH( boost::shared_ptr<IWbemClassObject> object, services_->execQuery( query ) )
    {
        boost::shared_ptr<ManagedElement> row( new ManagedElement );

        hr = object->BeginEnumeration(WBEM_FLAG_NONSYSTEM_ONLY);
        throwOnWmiError( hr, "enumerate WMI object properties" );
        
        for ( ;; )
        {
            BSTR rawName;
            VARIANT rawValue;
            hr = object->Next( 0, &rawName, &rawValue, 0, 0 );
            throwOnWmiError( hr, "iterate over WMI object properties" );
            if ( hr == WBEM_S_NO_MORE_DATA )
                break;

            _bstr_t name = _bstr_t( rawName, false ); // take ownership
            _variant_t value = _variant_t( rawValue, false ); // take ownership

                        QVariant qvalue = variantToQVariant( value );
            row->setProperty( name, qvalue );
        }
        result.addRow( row );
    }

    return result;
}

QString Confdump::System::WmiDumper::doComputerIdentifier()
{
        Result computers = queryTable( "Win32_ComputerSystemProduct" );
        if ( computers.begin() != computers.end() )
                return (*computers.begin())->property( "UUID" ).toString();
        else
                return QString();
}

QStringList Confdump::System::WmiDumper::doListTables()
{
    QStringList tables;

    BOOST_FOREACH( boost::shared_ptr<IWbemClassObject> object, services_->listAllClasses() )
    {
        VARIANT rawValue;
        HRESULT hr = object->Get( L"__CLASS", 0, &rawValue, 0, 0 );
        throwOnWmiError( hr, "get the enumerated class name" );
        _variant_t value = rawValue;

        try {
            _bstr_t strValue = value;
            tables.push_back( QString::fromWCharArray( strValue, strValue.length() ) );
        }
        catch ( _com_error& )
        {
            throw RuntimeError( "Unexpected type for an enumerated WMI class name, couldn't cast it to string" );
        }
    }

    return tables;
}