wmicollector.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
// Author: Barbara Packard ([e-mail])
//
// Modified By:	Adriano Zanuz ([e-mail])
//              Jair Santos, Hewlett-Packard Company ([e-mail])
//              Terry Martin, Hewlett-Packard Company ([e-mail])
//
//%/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// WMICollector::
//
/////////////////////////////////////////////////////////////////////////////

#include "StdAfx.h"

#include "WMIType.h"
#include "WMIFlavor.h"
#include "WMIValue.h"
#include "WMIString.h"
#include "WMIProperty.h"
#include "WMIMethod.h"
#include "WMICollector.h"

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
WMICollector::WMICollector(bool bLocal)
{
	m_bInitialized = false;
	m_bIsLocalNamespace = false;
	m_bImpersonate = false;
	m_bLocalConnection = bLocal;
}

WMICollector::~WMICollector(void)
{
}

void WMICollector::terminate(void)
{
	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::terminate()");

	if (m_bInitialized)
	{
		CoUninitialize();
		m_bInitialized = false;

		if(m_bImpersonate)
		{
			revertToSelf();
			m_bImpersonate = false;
		}

		m_bIsLocalNamespace = false;
    }

	PEG_METHOD_EXIT();
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::setup - calls CoInitialize stuff
//
/////////////////////////////////////////////////////////////////////////////
bool WMICollector::setup()
{
	HRESULT hr;

	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::setup()");

	if (!m_bInitialized)
	{
		hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);

		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::setup() - return from CoInitializeEx() is %x", hr); 

		m_bInitialized = (SUCCEEDED(hr));

		if (m_bInitialized)
		{
		    hr = CoInitializeSecurity(NULL, -1, NULL, NULL,
								      RPC_C_AUTHN_LEVEL_DEFAULT,
								      RPC_C_IMP_LEVEL_IMPERSONATE,
								      NULL,
                                      EOAC_DYNAMIC_CLOAKING, 
								      0);
        }
	}

    PEG_METHOD_EXIT();
	return (m_bInitialized);
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::Connect- attempt to establish a WMI connection with the local
//		host
//
/////////////////////////////////////////////////////////////////////////////
bool WMICollector::Connect(IWbemServices **ppServices)
{
	//
	// CComPtr is a smart pointer, therefore, it doesn't need to be explicitely
	// released.
	//
	CComPtr<IWbemLocator>	pLocator;
	CComPtr<IWbemServices>  pServices;
	HRESULT hr = S_OK;

	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::Connect()");
	
	// get the Locator object
	hr = pLocator.CoCreateInstance(CLSID_WbemLocator);
	
	Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
		"WMICollector::Connect() - return from CoCreateInstance() is %x", hr);

	if (SUCCEEDED(hr))	
	{
		if(m_bIsLocalNamespace)
		{
			Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
				"WMICollector::Connect() - m_bIsLocalNamespace is true");
			
			//Does not impersonate if is being called from a client app
			//Impersonate if it is being called from the Mapper service
			if (!m_bLocalConnection)
			{
				Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
					"WMICollector::Connect() - m_bLocalConnection is false, call logonUser()");
				logonUser();
			}
 						
			hr = pLocator->ConnectServer(m_bsNamespace, 
										 NULL, 
										 NULL,
										 NULL, 0L, NULL, NULL,
										 &pServices);
		}
		else
		{

			Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
				"WMICollector::Connect() - m_bIsLocalNamespace is false");
			//---------------------------------------------------
			//by Jair
			//adjusting the username in order to add the domain
			//reference
			CComBSTR bsUser = m_bsDomain;
			bsUser.Append("\\");
			bsUser.Append(m_bsUserName);

			//---------------------------------------------------

			hr = pLocator->ConnectServer(m_bsNamespace, 
										 bsUser,
										 m_bsPassword,
										 NULL, 0L, NULL, NULL,
										 &pServices);
		}

		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::Connect() - return from ConnectServer() is %x", hr);
		
		if (FAILED(hr))	
		{
			switch(hr)
			{
				case E_ACCESSDENIED:
					Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
						"WMICollector::Connect() connectServer() - throw CIM_ERR_ACCESS_DENIED for E_ACCESSDENIED error");
					throw CIMException(CIM_ERR_ACCESS_DENIED); 
					break;
				case WBEM_E_ACCESS_DENIED: 
					Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
						"WMICollector::Connect() - connectServer() - throw CIM_ERR_ACCESS_DENIED error");
					throw CIMException(CIM_ERR_ACCESS_DENIED); 
					break;
				default: 
					Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
						"WMICollector::Connect() - connectServer() - throw CIM_ERR_INVALID_NAMESPACE error");
					throw CIMException(CIM_ERR_INVALID_NAMESPACE);
			}
		}

        if (SUCCEEDED(hr))	
	    {
		    // set security attributes on pServices
		    if(setProxySecurity(pServices))
		    {
			    pServices.CopyTo(ppServices);
		    }
		    else	
		    {
			    *ppServices = NULL;
		    }
	    }
	}
	
	PEG_METHOD_EXIT();

	return (SUCCEEDED(hr));
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::getInstanceEnum - fetch a pointer to an enumeration of the
//		instances of sClassname
//
/////////////////////////////////////////////////////////////////////////////
bool WMICollector::getInstanceEnum(
					 IEnumWbemClassObject **ppInstances,
					 const String & sClassName,
					 Boolean deepInheritance)
{
	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::getInstanceEnum()");

	HRESULT hr;
	long lFlags = WBEM_FLAG_FORWARD_ONLY;

	//
	// CComPtr is a smart pointer, therefore, it doesn't need to be explicitely
	// released.
	//
	CComPtr<IWbemServices>			pServices;
	CComPtr<IEnumWbemClassObject>	p_inst;

	bool bConnected = Connect(&pServices);

	if (!bConnected)
	{
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::getInstanceEnum,() - bConnected is false - throw Connect failed error");
		
		throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED, "Connect failed.");
	}

	CComBSTR bsClassName = sClassName.getCString();

	deepInheritance ? lFlags |= WBEM_FLAG_DEEP : lFlags |= WBEM_FLAG_SHALLOW;

	// retrieve instances
	hr = pServices->CreateInstanceEnum(
		bsClassName,
		lFlags,
		NULL,
		&p_inst);

	Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::getInstanceEnum() return from CreateInstanceEnum()- hr value is %x", hr); 

    if (SUCCEEDED(hr))	
	{
		p_inst.CopyTo(ppInstances);

		// set security attributes on *ppInstances
		bool bSecurity = setProxySecurity(*ppInstances);
	}
	else	
	{
		*ppInstances = NULL;
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::getInstanceEnum() - hr value is %x", hr); 

		switch(hr)
		{
			case WBEM_E_ACCESS_DENIED: throw CIMException(CIM_ERR_ACCESS_DENIED); break;
			case WBEM_E_INVALID_CLASS: throw CIMException(CIM_ERR_INVALID_CLASS); break; 
			default: throw CIMException(CIM_ERR_FAILED, "[getInstanceEnum] general"); 
		}
	}

	PEG_METHOD_EXIT();

	return (SUCCEEDED(hr));
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::getClassEnum - fetch a pointer to an enumeration of the
//		classes satisfying the criteria
//
/////////////////////////////////////////////////////////////////////////////
bool WMICollector::getClassEnum(
					 IEnumWbemClassObject **ppClasses,
					 const String & sSuperClass,
					 Boolean deepInheritance)
{

	HRESULT hr;
	
	long lFlags = WBEM_FLAG_FORWARD_ONLY ;
	CComBSTR bsSuperClass = NULL;

	CComPtr<IWbemServices> pServices;
	CComPtr<IEnumWbemClassObject> p_class;

	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::getClassEnum()");

	bool bConnected = Connect(&pServices);

	if (!bConnected)
	{
        Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::getClassEnum,() - bConnected is false - throw Connect failed error");

		throw PEGASUS_CIM_EXCEPTION(CIM_ERR_ACCESS_DENIED, "Connect failed.");
	}

	//
	// workaround because there is no NULL for String class...
	//
	if (0 != sSuperClass.size())
	{
		bsSuperClass = sSuperClass.getCString();
	}

	deepInheritance ? lFlags |= WBEM_FLAG_DEEP : lFlags |= WBEM_FLAG_SHALLOW;

	if (0 != sSuperClass.size())
	{
	    // retrieve classes
	    hr = pServices->CreateClassEnum(
		    bsSuperClass,
		    lFlags,
		    NULL,
		    &p_class);
    }
	else
	{
		// retrieve classes
		hr = pServices->CreateClassEnum(
			NULL,
			lFlags,
			NULL,
			&p_class);
	}

	Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
		"WMICollector::getClassEnum() returns from CreateClassEnum() - hr value is %x", hr);

	if (SUCCEEDED(hr))	
	{
		p_class.CopyTo(ppClasses);

		// set security attributes on *ppClasses
		bool bSecurity = setProxySecurity(*ppClasses);
	}
	else	
	{
		*ppClasses = NULL;

        Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::getClassEnum() - hr value is %x", hr);
		
		switch(hr)
		{
			case WBEM_E_ACCESS_DENIED: 
				Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
					"WMICollector::getClassEnum() - createClassEnum() returns ACCESS_DENIED- throw CIM_ERROR_ACCESS_DENIED error");
				throw CIMException(CIM_ERR_ACCESS_DENIED); 
				break;
			case WBEM_E_INVALID_CLASS: 
				Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
					"WMICollector::getClassEnum() - createClassEnum() returns INVALID_CLASS- throw CIM_INVALID_CLASS error");
				throw CIMException(CIM_ERR_INVALID_CLASS); 
				break; 
			default: 
				Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
					"WMICollector::getClassEnum() - createClassEnum() returns default - throw getClassEnum general error");
				throw CIMException(CIM_ERR_FAILED, "[getClassEnum] general"); 
		}
	}

	PEG_METHOD_EXIT();

	return (SUCCEEDED(hr));
}


/////////////////////////////////////////////////////////////////////////////
// WMICollector::getQueryResult - fetch a point to the enumeration of
//		instances returned from an ExecQuery request 
//
/////////////////////////////////////////////////////////////////////////////
bool WMICollector::getQueryResult(
					IEnumWbemClassObject **ppInstances, 
					const String &query, 
					const String &queryLanguage)
{
	HRESULT hr;
	
	CComPtr<IWbemServices>	pServices;
	CComPtr<IEnumWbemClassObject> p_inst;

	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::getQueryResult()");