wmicollector.cpp

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

	CMyString sPropName; sPropName = bsName;
	long iSize = sPropName.GetLength();

	Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
		"WMICollector::getProperty() - Property Name is %s, type is %x, CIMTYPE is %x", 
		(LPCTSTR)sPropName, vValue.vt, type);

	// put this in to check XP - @bbp
	if (VT_BSTR == vValue.vt)
	{
		CComBSTR bs;
		bs.Empty();
		bs.Append(vValue.bstrVal);
		sPropName = bs;
		iSize = sPropName.GetLength();
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::getProperty() - Property Value is %s, size is %x", 
			(LPCTSTR)sPropName, iSize);
	}

	CComPtr<IWbemQualifierSet> pQualifiers;

	// get the qualifier set for the properties
	sMessage = "GetPropertyQualifierSet()";
	hr = pClass->GetPropertyQualifierSet(bsName, &pQualifiers);

	if (SUCCEEDED(hr))
	{
		property = WMIProperty(bsName, vValue, type, pQualifiers, includeQualifiers);

		// set the property qualifier
		property.setPropagated(bPropagated);
	}

	// check if requested ClassOrigin qualifier
	// ATTN:
	// This is a bug in Pegasus.  It will put it
	//	the current class for GetClass if it isn't
	//	there.
	if ((includeClassOrigin /*|| bPropagated*/) && SUCCEEDED(hr))
	{
		CComBSTR		bsClassOrigin;
		sMessage = "GetPropertyOrigin()";

		hr = pClass->GetPropertyOrigin(bsName, & bsClassOrigin);

		if (SUCCEEDED(hr))
		{
			property.setClassOrigin(WMIString(bsClassOrigin));
		}
	}

	if (pQualifiers)
		pQualifiers.Release();

	if (FAILED(hr))
	{
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::getProperty() - %s result is %x", sMessage, hr);

		throw CIMException(CIM_ERR_FAILED);
	}

	PEG_METHOD_EXIT();

	return property;
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::getClassMethods - retrieves the 
//		class method definitions and parameters, if any,
//		and adds them to the CIMClass instance
//
/////////////////////////////////////////////////////////////////////////////
bool WMICollector::getClassMethods(IWbemClassObject *pObject, 
									  CIMClass & cimClass,
									  Boolean localOnly,
									  Boolean includeQualifiers,
									  Boolean includeClassOrigin)
{
 	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::getClasslMethods()");

	long lFlags = (localOnly) ? WBEM_FLAG_LOCAL_ONLY : 0L;

	// we want all the methods...
	getAllMethods(pObject, lFlags, includeQualifiers, includeClassOrigin, cimClass);

	PEG_METHOD_EXIT();

	return true;
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::getMethod
//		create a CIMMethod object from
//		WMI data 
//
/////////////////////////////////////////////////////////////////////////////
CIMMethod WMICollector::getMethod(IWbemClassObject *pClass, 
								  const CComBSTR &bsName, 
								  const CComPtr<IWbemClassObject> &inParameters,
								  const CComPtr<IWbemClassObject> &outParameters,
								  Boolean includeClassOrigin, 
								  Boolean includeQualifiers,
								  Boolean bPropagated)
{
	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::getMethod()");
	
	HRESULT hr = S_OK;
	String sMessage;
	CIMMethod method;
	CMyString sMethodName; sMethodName = bsName;
	long iSize = sMethodName.GetLength();

	Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
		"WMICollector::getMethod() - Method Name is %s", 
		(LPCTSTR)sMethodName);


	CComPtr<IWbemQualifierSet> pQualifiers;

	// get the qualifier set for the method
	sMessage = "GetMethodQualifierSet()";
	hr = pClass->GetMethodQualifierSet(bsName, &pQualifiers);

	if (SUCCEEDED(hr))
	{
		method = WMIMethod(bsName, inParameters, outParameters, pQualifiers, includeQualifiers);

		// set the method qualifier
		method.setPropagated(bPropagated);
	}

	// check if requested ClassOrigin qualifier
	// ATTN:
	// This is a bug in Pegasus.  It will put it
	//	the current class for GetClass if it isn't
	//	there.
	if ((includeClassOrigin /*|| bPropagated*/) && SUCCEEDED(hr))
	{
		CComBSTR		bsClassOrigin;
		sMessage = "GetMethodOrigin()";

		hr = pClass->GetMethodOrigin(bsName, & bsClassOrigin);

		if (SUCCEEDED(hr))
		{
			method.setClassOrigin(WMIString(bsClassOrigin));
		}
	}

	if (pQualifiers)
		pQualifiers.Release();

	if (FAILED(hr))
	{
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::getMethod() - %s result is %x", sMessage, hr);

		throw CIMException(CIM_ERR_FAILED);
	}

	PEG_METHOD_EXIT();

	return method;
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::setNamespace
//	 
//
/////////////////////////////////////////////////////////////////////////////
void WMICollector::setNamespace(const String & sNamespace)
{
	String s;

	String sLower = sNamespace;
	sLower.toLower();
	Uint32 pos = sLower.find("root");
	
	m_bIsLocalNamespace = (0 == pos);

	if (m_bIsLocalNamespace)
	{
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::setNamespace() - Namespace %s is local", sNamespace.getCString());
		s = sNamespace;
	}
	else
	{
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
			"WMICollector::setNamespace() - Namespace %s is remote", sNamespace.getCString());

		// by Jair 
		// adjust the namespace to accept DNS fully qualified names
		// and IP addresses.
		String str = sNamespace;
		for (Uint32 i = 0; i < pos - 1; i++)
		{
			if (str[i] == '/') 
			{
                // have a '.' encoded as '/' -- convert back to '.':
				str[i] = '.';
			}
			else if (str[i] == '_')
			{
                if (str[i + 1] == '_' &&
                    iswxdigit(str[i + 2]) &&
                    iswxdigit(str[i + 3]))
                {
                    // have a non-alpha char (punctuation, etc.) encoded as
                    // "__XX", where XX is the hex representation of the char
                    String hexStr = str.subString(i+2, 2);
                    Char16 punctChar = (Char16)wcstol(
                        (const wchar_t *)hexStr.getChar16Data(), NULL, 16);
                    // replace the first underscore with the non-alpha char:
                    str[i] = punctChar;
                    // remove the second underscore + 2 hex chars:
                    str.remove(i+1, 3);
                    pos -= 3;
                }
                else if (iswdigit(str[i + 1]))
				{
                    if ((i == 0) || (str[i - 1] == '.'))
					{
                        // have a leading digit pre-pended with an underscore
                        // remove the underscore:
						str.remove(i, 1);
						pos--;
					}
				}
			}
		}

		//prepend "//" to namespace
		s = "//";
		s.append(str);
	}

	m_bsNamespace = s.getCString();
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::setUserName
//	 
//
/////////////////////////////////////////////////////////////////////////////
void WMICollector::setUserName(const String & sUserName)
{
	String sUser = sUserName;
	String sDomain = ".";

	Uint32 pos = sUser.find("/");
	
	if (PEG_NOT_FOUND == pos)
		pos = sUser.find("\\");

	if (pos != PEG_NOT_FOUND)
	{
		sDomain = sUser.subString(0, pos);
		sUser.remove(0, pos + 1);
	}

	Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
				"WMICollector::setUserName() - UserName [%s], Domain [%s]", 
				sUser.getCString(), sDomain.getCString());

	m_bsUserName = sUser.getCString();
	m_bsDomain = sDomain.getCString();
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::setPassword
//	 
//
// ///////////////////////////////////////////////////////////////////////////
void WMICollector::setPassword(const String & sPassword)
{
	Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
				"WMICollector::setPassword() - Password %s", sPassword.getCString());

	m_bsPassword = sPassword.getCString();
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::setProxySecurity
//	 
//
/////////////////////////////////////////////////////////////////////////////
bool WMICollector::setProxySecurity(IUnknown * pProxy)
{
	PEG_METHOD_ENTER(TRC_WMIPROVIDER,"WMICollector::setProxySecurity()");

    HRESULT hr;

	if(m_bIsLocalNamespace)
	{
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
				"WMICollector::setProxySecurity() - m_bIsLocalNamespace is true");

        hr = CoSetProxyBlanket(
			pProxy,
			RPC_C_AUTHN_WINNT,    // NTLM authentication service
			RPC_C_AUTHZ_NONE,     // default authorization service...
			NULL,                 // no mutual authentication
			RPC_C_AUTHN_LEVEL_PKT,      // authentication Tracer::LEVEL
			RPC_C_IMP_LEVEL_IMPERSONATE, // impersonation Tracer::LEVEL
			NULL,                
			EOAC_DYNAMIC_CLOAKING);     // enable dynamic cloaking, so 
                                        // impersonation token is propagated to WMI
	}
	else
	{
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
				"WMICollector::setProxySecurity() - m_bIsLocalNamespace is false");

        // set security attributes on pProxy
		COAUTHIDENTITY authident;
			
		memset((void *)&authident,0,sizeof(COAUTHIDENTITY));

		authident.UserLength = (ULONG)m_bsUserName.Length();
		authident.User = (LPWSTR)m_bsUserName.m_str;
		authident.PasswordLength = (ULONG)m_bsPassword.Length();
		authident.Password = (LPWSTR)m_bsPassword.m_str;
		authident.DomainLength = (ULONG)m_bsDomain.Length();
		authident.Domain = (LPWSTR)m_bsDomain.m_str;
		authident.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;

		hr = CoSetProxyBlanket(
				pProxy,
				RPC_C_AUTHN_WINNT,    // NTLM authentication service
				RPC_C_AUTHZ_NONE,     // default authorization service...
				NULL,                 // no mutual authentication
				RPC_C_AUTHN_LEVEL_PKT,      // authentication Tracer::LEVEL
				RPC_C_IMP_LEVEL_IMPERSONATE,    // impersonation Tracer::LEVEL
				&authident, 
			    EOAC_NONE); // EOAC_DYNAMIC_CLOAKING seems to fail on remote WMI calls,
                            // or when COAUTHIDENTITY info is sent (as in this case),
                            // so going back to EOC_NONE for this case only.
	}

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

	PEG_METHOD_EXIT();
	return SUCCEEDED(hr);
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::logonUser
//	 
//
/////////////////////////////////////////////////////////////////////////////
void WMICollector::logonUser()
{
	CMyString sUserName, sDomain, sPassword;

	sUserName = (LPWSTR)m_bsUserName.m_str;
	sDomain   = (LPWSTR)m_bsDomain.m_str;
	sPassword = (LPWSTR)m_bsPassword.m_str;

	LPTSTR pszUserName  = (LPTSTR)(LPCTSTR)sUserName;
	LPTSTR pszDomain    = (LPTSTR)(LPCTSTR)sDomain;
	LPTSTR pszPassword  = (LPTSTR)(LPCTSTR)sPassword;

    //Logon and impersonate the user
	if(!RevertToSelf())
	{
		DWORD error = GetLastError();
		
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
				"WMICollector::logonUser() - return from RevertToSelf() is %d", error);

		throw CIMException(CIM_ERR_ACCESS_DENIED, "RevertToSelf()");
	}

	HANDLE htok = 0;
	if(!LogonUser(pszUserName,
		          pszDomain,
				  pszPassword,
				  LOGON32_LOGON_INTERACTIVE,
				  LOGON32_PROVIDER_DEFAULT,
				  &htok))
	{
		DWORD error = GetLastError();
	
		Tracer::trace(TRC_WMIPROVIDER, Tracer::LEVEL3,
				"WMICollector::logonUser() - return from LogonUser() is %d", error);
				
        Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                    "Failed to login user \"$0/$1\". Invalid username or password.",
                    pszDomain, pszUserName);
		
        throw CIMException(CIM_ERR_ACCESS_DENIED, "LogonUser()");
	}

	if(!ImpersonateLoggedOnUser(htok))
	{
		DWORD error = GetLastError();
		CloseHandle(htok);

        Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::WARNING,
                    "Failed to impersonate logged-in user \"$0/$1\".",
                    pszDomain, pszUserName);
		
		throw CIMException(CIM_ERR_ACCESS_DENIED, "ImpersonateLoggedOnUser()");
	}

	CloseHandle(htok);
	m_bImpersonate = true;
}

/////////////////////////////////////////////////////////////////////////////
// WMICollector::revertToSelf
//	 
//
/////////////////////////////////////////////////////////////////////////////
void WMICollector::revertToSelf()
{
	if(!RevertToSelf())
	{
		throw CIMException(CIM_ERR_FAILED, "RevertToSelf()");
	}
}

PEGASUS_NAMESPACE_END