errors.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 "boost/type_traits/make_unsigned.hpp"
#include "Confdump/System/Wmi/errors.hpp"

using boost::shared_ptr;

namespace Confdump
{
namespace System
{
namespace Wmi
{

Win32Error::Win32Error( QString message, HRESULT hr )
 : RuntimeError( message ), hresult_( hr )
{
}

Win32Error::~Win32Error()
{
}

HRESULT Win32Error::hresult() const
{
    return hresult_;
}

QString Win32Error::hresultAsHex() const
{
    // HRESULT is signed so that failures are <0. Reinterpret its bit pattern
    // as not signed for display purposes.
    typedef boost::make_unsigned<HRESULT>::type Uhresult;
    Uhresult uvalue = *reinterpret_cast<const Uhresult*>( &hresult_ );
    return "0x" + QString::number( uvalue, 16 );
}




ComError::ComError( HRESULT hr, QString action )
 : Win32Error( "ComError", hr ), comError_( hr )
{
    setMessage( QString( "Failed to %1: %2 (%3)." )
                                .arg( action ).arg( errorMessage() ).arg( hresultAsHex() ) );
}

ComError::~ComError()
{
}

QString ComError::errorMessage() const
{
    return QString::fromWCharArray( comError_.ErrorMessage() );
}

WmiError::WmiError( QString statusDump, HRESULT hr, QString action )
 : Win32Error( "WmiError", hr )
{
        WmiDiagnostics diag( hr );
        
    setMessage( QString( "Failed to %1. Error code %3, extended info: %2\n"
                                        "Possible cause: %4\n" )
                                .arg( action ).arg( statusDump ).arg( hresultAsHex() )
                                .arg( diag.knownError() ? diag.toString() : "" ) );
}

WmiError::~WmiError()
{
}



void throwOnWmiError( HRESULT hr, QString action, QString element )
{
        /* Implementation note: this code is ugly, but the throwOn*Error mechanism
         * can't be used here. There is only one exception of interest that may be
         * thrown here: whatever caused throwOnWmiError() to be called in the first
         * place.
         */
    if ( FAILED( hr ) )
    {
                // First get an ErrorInfo. Not useful as such because its Description is empty.
        IErrorInfo *rawError = 0;
        if ( GetErrorInfo( 0, &rawError ) == S_OK )
        {
                        shared_ptr<IErrorInfo> error = guardComObject( rawError );
                        
                        // From there, get a WMI object with useful hints in its properties
                        IWbemClassObject *rawStatus = 0;
                        if ( error->QueryInterface( IID_IWbemClassObject,
                                reinterpret_cast<void**>( &rawStatus ) ) == S_OK )
                        {
                                shared_ptr<IWbemClassObject> status = guardComObject( rawStatus );
                                
                                // Usually this is an __ExtendedStatus, but we're not sure and don't
                                // really want to dive into it, so let's just dump it to the user
                                BSTR rawText;
                                if ( status->GetObjectText( 0, &rawText ) == S_OK )
                                {
                                        _bstr_t text( rawText );
                                        throw WmiError( QString::fromWCharArray( text, text.length() ),
                                                hr, action );
                                }
                        }
        }
        
        throwOnComError( hr, action ); // Fallback if no WMI error found
    }
}

void throwOnComError( HRESULT hr, QString action )
{
        if ( FAILED( hr ) )
        throw ComError( hr, action );
}


WmiDiagnostics::WmiDiagnostics( HRESULT hr )
 : hr_( hr )
{
        switch ( hr )
        {
        case 0x80041014: // "failed to initialize component for internal reasons"
                cause_ = "Query results too large for this computer";
                break;
        case 0x80041024:
                cause_ = "WMI class is not enumerable";
                break;
        case 0x80041003:
                cause_ = "Access denied";
                break;
        }
}

bool WmiDiagnostics::knownError() const
{
        return !cause_.isNull();
}

QString WmiDiagnostics::toString() const
{
        return cause_;
}


}
}
}