|
|
/*++
Copyright (C) 1998-2001 Microsoft Corporation
Module Name:
COMTRANS.CPP
Abstract:
Connects via COM
History:
a-davj 13-Jan-98 Created.
--*/
#include "precomp.h"
#include <wbemidl.h>
#include <wbemint.h>
#include <reg.h>
#include <wbemutil.h>
#include <objidl.h>
#include <cominit.h>
#include "wbemprox.h"
#include "comtrans.h"
#include <winntsec.h>
#include <genutils.h>
#include <arrtempl.h>
#include <wmiutils.h>
#include <strsafe.h>
#include <winsock2.h>
#include <autoptr.h>
// The following should not be changed since 9x boxes to not support privacy.
#define AUTH_LEVEL RPC_C_AUTHN_LEVEL_DEFAULT
class CSocketInit{ private: bool m_bInitDone; public: CSocketInit() : m_bInitDone(false){}; int Init(); ~CSocketInit(){if(m_bInitDone) WSACleanup ();};};
int CSocketInit::Init(){ WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD( 2, 2 ); int iRet = WSAStartup (wVersionRequested, & wsaData); if(iRet == 0) m_bInitDone = true; return iRet;}
BOOL bGotDot(char * pTest){ if(pTest == NULL) return FALSE; for(;*pTest && *pTest != '.'; pTest++); // intentional semi
if(*pTest == '.') return TRUE; else return FALSE; } struct hostent * GetFQDN(WCHAR * pServer){ SIZE_T Len = wcslen(pServer); SIZE_T LenAnsi = 4*Len; wmilib::auto_buffer<CHAR> pAnsiServerName(new CHAR[LenAnsi+1]); ULONG BytesCopyed = 0; //
// Use the same routine that RPCRT4 uses
//
NTSTATUS Status = RtlUnicodeToMultiByteN(pAnsiServerName.get(),LenAnsi,&BytesCopyed,pServer,Len*sizeof(WCHAR)); if (0 != Status) return NULL; pAnsiServerName[BytesCopyed] = 0; // if it is an ip string
long lIP = inet_addr(pAnsiServerName.get()); if(lIP != INADDR_NONE) { struct hostent * pRet = gethostbyaddr((char *)&lIP, 4, AF_INET ); if(pRet && pRet->h_name) { // search the returned name for at least one dot. Sometimes, gethostbyaddr will just return
// the lanman name and not the fqdn.
if(bGotDot(pRet->h_name)) return pRet; // normal case, all is well!
// try passing the short name to get the fqdn version
DWORD dwLen = lstrlenA(pRet->h_name) + 1; char * pNew = new char[dwLen]; if(pNew == NULL) return NULL; CVectorDeleteMe<char> dm2(pNew); StringCchCopyA(pNew, dwLen, pRet->h_name); pRet = gethostbyname(pNew); if(pRet && bGotDot(pRet->h_name)) return pRet; // normal case, all is well!
} } return gethostbyname(pAnsiServerName.get()); }
#define PREFIXSTR L"RPCSS/"
HRESULT BuildReturnString(WCHAR * pFQDN, WCHAR ** ppResult){ if(pFQDN == NULL) return WBEM_E_INVALID_PARAMETER; DWORD dwBuffLen = wcslen(pFQDN) + wcslen(PREFIXSTR) + 1; *ppResult = new WCHAR[dwBuffLen]; if(*ppResult == NULL) return WBEM_E_OUT_OF_MEMORY; StringCchCopy(*ppResult, dwBuffLen, PREFIXSTR); StringCchCat(*ppResult, dwBuffLen, pFQDN); return S_OK;}
HRESULT GetPrincipal(WCHAR * pServerMachine, WCHAR ** ppResult, BOOL &bLocal, CSocketInit & sock){
DWORD dwLocalFQDNLen = 0; DWORD dwBuffLen; WCHAR * pwsCurrentCompFQDN = NULL; bLocal = FALSE; *ppResult = NULL; // Get the current computer name in FQDN format
BOOL bRet = GetComputerNameEx(ComputerNameDnsFullyQualified, NULL, &dwLocalFQDNLen); if(bRet || GetLastError() != ERROR_MORE_DATA) return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32,GetLastError()); dwLocalFQDNLen++; // add one for the null
pwsCurrentCompFQDN = new WCHAR[dwLocalFQDNLen]; if(pwsCurrentCompFQDN == NULL) return WBEM_E_OUT_OF_MEMORY; CVectorDeleteMe<WCHAR> dm(pwsCurrentCompFQDN); bRet = GetComputerNameEx(ComputerNameDnsFullyQualified, pwsCurrentCompFQDN, &dwLocalFQDNLen); if(!bRet) return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32,GetLastError()); // if the name is "." or equal to the current machine, no need to do much fancy work here
if(bAreWeLocal ( pServerMachine )) { bLocal = TRUE; return BuildReturnString(pwsCurrentCompFQDN, ppResult); } // probably not local. Use sockets to establish the FQDN of the server
if(0 != sock.Init()) return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32,GetLastError()); struct hostent * pEnt = GetFQDN(pServerMachine); if(pEnt == NULL || pEnt->h_name == NULL) { // we failed. just return the best we can
return BuildReturnString(pServerMachine, ppResult); }
// all is well. Convert the host name to WCHAR.
DWORD dwHostLen = lstrlenA(pEnt->h_name) + 1; WCHAR * pwsHostFQDN = new WCHAR[dwHostLen]; if(pwsHostFQDN == NULL) return WBEM_E_OUT_OF_MEMORY; CVectorDeleteMe<WCHAR> dm2(pwsHostFQDN); mbstowcs(pwsHostFQDN, pEnt->h_name, dwHostLen);
// now there is the possibility that they specified the ip of the local machine.
// In that case, set the bLocal in case caller needs to know this
if(wbem_wcsicmp(pwsHostFQDN, pwsCurrentCompFQDN) == 0) bLocal = TRUE;
// now, make the actual string.
return BuildReturnString(pwsHostFQDN, ppResult);}
//***************************************************************************
//
// CDCOMTrans::CDCOMTrans
//
// DESCRIPTION:
//
// Constructor.
//
//***************************************************************************
CDCOMTrans::CDCOMTrans(){ m_cRef=0; m_pLevel1 = NULL; InterlockedIncrement(&g_cObj); m_bInitialized = TRUE;}
//***************************************************************************
//
// CDCOMTrans::~CDCOMTrans
//
// DESCRIPTION:
//
// Destructor.
//
//***************************************************************************
CDCOMTrans::~CDCOMTrans(void){ if(m_pLevel1) m_pLevel1->Release(); InterlockedDecrement(&g_cObj);}
//***************************************************************************
// HRESULT CDCOMTrans::QueryInterface
// long CDCOMTrans::AddRef
// long CDCOMTrans::Release
//
// DESCRIPTION:
//
// Standard Com IUNKNOWN functions.
//
//***************************************************************************
STDMETHODIMP CDCOMTrans::QueryInterface (
IN REFIID riid, OUT PPVOID ppv){ *ppv=NULL;
if (m_bInitialized && (IID_IUnknown==riid || riid == IID_IWbemClientTransport)) *ppv=(IWbemClientTransport *)this;
if (NULL!=*ppv) { ((LPUNKNOWN)*ppv)->AddRef(); return NOERROR; }
return ResultFromScode(E_NOINTERFACE);}
bool IsImpersonating(SECURITY_IMPERSONATION_LEVEL &impLevel){ HANDLE hThreadToken; bool bImpersonating = false; if(OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE, &hThreadToken)) {
DWORD dwBytesReturned = 0; if(GetTokenInformation( hThreadToken, TokenImpersonationLevel, &impLevel, sizeof(DWORD), &dwBytesReturned ) && ((SecurityImpersonation == impLevel) || (SecurityDelegation == impLevel))) bImpersonating = true; CloseHandle(hThreadToken); } return bImpersonating;}
//***************************************************************************
//
// IsLocalConnection(IWbemLevel1Login * pLogin)
//
// DESCRIPTION:
//
// Querries the server to see if this is a local connection. This is done
// by creating a event and asking the server to set it. This will only work
// if the server is the same box.
//
// RETURN VALUE:
//
// true if the server is the same box.
//
//***************************************************************************
BOOL IsLocalConnection(IUnknown * pInterface){ IRpcOptions *pRpcOpt = NULL; ULONG_PTR dwProperty = 0; HRESULT hr = pInterface->QueryInterface(IID_IRpcOptions, (void**)&pRpcOpt); //DbgPrintfA(0,"QueryInterface(IID_IRpcOptions) hr = %08x\n",hr);
if (SUCCEEDED(hr)) { hr = pRpcOpt->Query(pInterface, COMBND_SERVER_LOCALITY, &dwProperty); pRpcOpt->Release(); if (SUCCEEDED(hr)) return (SERVER_LOCALITY_REMOTE == dwProperty)?FALSE:TRUE; } else if (E_NOINTERFACE == hr) // real pointer, not a proxy
{ return TRUE; } return FALSE;}
//***************************************************************************
//
// SetClientIdentity
//
// DESCRIPTION:
//
// Passes the machine name and process id to the server. Failure is not
// serious since this is debugging type info in any case.
//
//***************************************************************************
void SetClientIdentity(IUnknown * pLogin, bool bSet, BSTR PrincipalArg, DWORD dwAuthenticationLevel, COAUTHIDENTITY *pauthident, DWORD dwCapabilities, DWORD dwAuthnSvc){ bool bRet = false; IWbemLoginClientID * pLoginHelper = NULL; SCODE sc = pLogin->QueryInterface(IID_IWbemLoginClientID, (void **)&pLoginHelper); if(sc != S_OK) return;
if(bSet) sc = WbemSetProxyBlanket( pLoginHelper, dwAuthnSvc, RPC_C_AUTHZ_NONE, PrincipalArg, dwAuthenticationLevel, RPC_C_IMP_LEVEL_IMPERSONATE, pauthident, dwCapabilities);
CReleaseMe rm(pLoginHelper); TCHAR tcMyName[MAX_COMPUTERNAME_LENGTH + 1]; DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1; if(!GetComputerName(tcMyName,&dwSize)) return; long lProcID = GetCurrentProcessId(); pLoginHelper->SetClientInfo(tcMyName, lProcID, 0); }
SCODE CDCOMTrans::DoConnection( BSTR NetworkResource, BSTR User, BSTR Password, BSTR Locale, long lFlags, BSTR Authority, IWbemContext *pCtx, IWbemServices **pInterface){ HRESULT hr = DoActualConnection(NetworkResource, User, Password, Locale, lFlags, Authority, pCtx, pInterface);
if(hr == 0x800706be) { ERRORTRACE((LOG_WBEMPROX,"Initial connection failed with 0x800706be, retrying\n")); Sleep(5000); hr = DoActualConnection(NetworkResource, User, Password, Locale, lFlags, Authority, pCtx, pInterface); } return hr;}
SCODE CDCOMTrans::DoActualConnection( BSTR NetworkResource, BSTR User, BSTR Password, BSTR Locale, long lFlags, BSTR Authority, IWbemContext *pCtx, IWbemServices **pInterface){
BSTR AuthArg = NULL, UserArg = NULL; // this is the pricipal as extracted from the optional Authority argument
BSTR PrincipalArg = NULL;
// this is the pricipal which is calculated from the server name in the path
WCHAR * pwCalculatedPrincipal = NULL;
bool bAuthenticate = true; bool bSet = false; CSocketInit sock; SCODE sc = WBEM_E_FAILED;
sc = DetermineLoginTypeEx(AuthArg, UserArg, PrincipalArg, Authority, User); if(sc != S_OK) { ERRORTRACE((LOG_WBEMPROX, "Cannot determine Login type, Authority = %S, User = %S\n",Authority, User)); return sc; } CSysFreeMe fm1(AuthArg); CSysFreeMe fm2(UserArg); CSysFreeMe fm3(PrincipalArg);
// Determine if it is local
WCHAR *t_ServerMachine = ExtractMachineName ( NetworkResource ) ; if ( t_ServerMachine == NULL ) { ERRORTRACE((LOG_WBEMPROX, "Cannot extract machine name -%S-\n", NetworkResource)); return WBEM_E_INVALID_PARAMETER ; } CVectorDeleteMe<WCHAR> dm(t_ServerMachine);
BOOL t_Local; if(PrincipalArg == NULL) { sc = GetPrincipal(t_ServerMachine, &pwCalculatedPrincipal, t_Local, sock); if(FAILED(sc)) { t_Local = bAreWeLocal(t_ServerMachine); ERRORTRACE((LOG_WBEMPROX, "GetPrincipal(%S) hr = %08x\n",t_ServerMachine,sc)); } else { DEBUGTRACE((LOG_WBEMPROX, "Using the principal -%S-\n", pwCalculatedPrincipal)); } } else t_Local = bAreWeLocal(t_ServerMachine); CVectorDeleteMe<WCHAR> dm2(pwCalculatedPrincipal);
SECURITY_IMPERSONATION_LEVEL impLevel = SecurityImpersonation; bool bImpersonatingThread = IsImpersonating (impLevel); bool bCredentialsSpecified = (UserArg || AuthArg || Password);
// Setup the authentication structures
COSERVERINFO si; si.pwszName = t_ServerMachine; si.dwReserved1 = 0; si.dwReserved2 = 0; si.pAuthInfo = NULL;
COAUTHINFO ai; si.pAuthInfo = &ai;
ai.dwAuthzSvc = RPC_C_AUTHZ_NONE; if(PrincipalArg) { ai.dwAuthnSvc = RPC_C_AUTHN_GSS_KERBEROS; ai.pwszServerPrincName = PrincipalArg; } else if (pwCalculatedPrincipal) { ai.dwAuthnSvc = RPC_C_AUTHN_GSS_NEGOTIATE; ai.pwszServerPrincName = pwCalculatedPrincipal; } else { ai.dwAuthnSvc = RPC_C_AUTHN_WINNT; ai.pwszServerPrincName = NULL; } ai.dwAuthnLevel = AUTH_LEVEL; ai.dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE; ai.dwCapabilities = 0;
COAUTHIDENTITY authident;
if(bCredentialsSpecified) { // Load up the structure.
memset((void *)&authident,0,sizeof(COAUTHIDENTITY)); if(UserArg) { authident.UserLength = wcslen(UserArg); authident.User = (LPWSTR)UserArg; } if(AuthArg) { authident.DomainLength = wcslen(AuthArg); authident.Domain = (LPWSTR)AuthArg; } if(Password) { authident.PasswordLength = wcslen(Password); authident.Password = (LPWSTR)Password; } authident.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE; ai.pAuthIdentityData = &authident; } else ai.pAuthIdentityData = NULL; // Get the IWbemLevel1Login pointer
sc = DoCCI(&si ,t_Local, lFlags);
if((sc == 0x800706d3 || sc == 0x800706ba) && !t_Local) { // If we are going to a stand alone dcom box, try again with the authentication level lowered
ai.dwAuthnLevel = RPC_C_AUTHN_LEVEL_NONE; SCODE hr = DoCCI(&si ,t_Local, lFlags); if(hr == S_OK) { sc = S_OK; bAuthenticate = false; } }
if(sc != S_OK) return sc;
// Set the values used for CoSetProxyBlanket calls. If the principal was passed in via the Authority
// argument, then it is used and kerberos is forced. Otherwise, the values will be set based on
// querying the Proxy it will be either NULL (if NTLM is used) or COLE_DEFAULT_PRINCIPAL.
DWORD dwAuthnSvc = RPC_C_AUTHN_WINNT; WCHAR * pwCSPBPrincipal = NULL; if(PrincipalArg) { dwAuthnSvc = RPC_C_AUTHN_GSS_KERBEROS; pwCSPBPrincipal = PrincipalArg; } else {
DWORD dwQueryAuthnLevel, dwQueryImpLevel, dwQueryCapabilities; HRESULT hr = CoQueryProxyBlanket( m_pLevel1, //Location for the proxy to query
&dwAuthnSvc, //Location for the current authentication service
NULL, //Location for the current authorization service
NULL, //Location for the current principal name
&dwQueryAuthnLevel, //Location for the current authentication level
&dwQueryImpLevel, //Location for the current impersonation level
NULL, &dwQueryCapabilities //Location for flags indicating further capabilities of the proxy
);
if(SUCCEEDED(hr) && dwAuthnSvc != RPC_C_AUTHN_WINNT) { pwCSPBPrincipal = COLE_DEFAULT_PRINCIPAL; } else { dwAuthnSvc = RPC_C_AUTHN_WINNT; pwCSPBPrincipal = NULL; } } // The authentication level is set based on having to go to a share level box or not. The
// capabilities are set based on if we are an impersonating thread or not
DWORD dwAuthenticationLevel, dwCapabilities; if(bAuthenticate) dwAuthenticationLevel = AUTH_LEVEL; else dwAuthenticationLevel = RPC_C_AUTHN_LEVEL_NONE;
if(bImpersonatingThread && !UserArg) dwCapabilities = EOAC_STATIC_CLOAKING; else dwCapabilities = EOAC_NONE; // Do the security negotiation
if(!t_Local) { // Suppress the SetBlanket call if we are on a Win2K delegation-level thread with implicit credentials
if (!(bImpersonatingThread && !bCredentialsSpecified && (SecurityDelegation == impLevel))) { // Note that if we are on a Win2K impersonating thread with no user specified
// we should allow DCOM to use whatever EOAC capabilities are set up for this
// application. This allows remote connections with NULL User/Password but
// non-NULL authority to succeed.
sc = WbemSetProxyBlanket( m_pLevel1, dwAuthnSvc, RPC_C_AUTHZ_NONE, pwCSPBPrincipal, dwAuthenticationLevel, RPC_C_IMP_LEVEL_IMPERSONATE, (bCredentialsSpecified) ? &authident : NULL, dwCapabilities);
bSet = true; if(sc != S_OK) { ERRORTRACE((LOG_WBEMPROX,"Error setting Level1 login interface security pointer, return code is 0x%x\n", sc)); return sc; } } } else // LOCAL case
{ // if impersonating set cloaking
if(bImpersonatingThread) { sc = WbemSetProxyBlanket( m_pLevel1, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, dwAuthenticationLevel, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_STATIC_CLOAKING); if(sc != S_OK && sc != 0x80004002) // no such interface is ok since you get that when
// called inproc!
{ ERRORTRACE((LOG_WBEMPROX,"Error setting Level1 login interface security pointer, return code is 0x%x\n", sc)); return sc; } }
}
SetClientIdentity(m_pLevel1, bSet, PrincipalArg, dwAuthenticationLevel, &authident, dwCapabilities, dwAuthnSvc); if(bCredentialsSpecified && IsLocalConnection(m_pLevel1)) { ERRORTRACE((LOG_WBEMPROX,"Credentials were specified for a local connections\n")); return WBEM_E_LOCAL_CREDENTIALS; }
// The MAX_WAIT flag only applies to CoCreateInstanceEx, get rid of it
lFlags = lFlags & ~WBEM_FLAG_CONNECT_USE_MAX_WAIT; sc = m_pLevel1->NTLMLogin(NetworkResource, Locale, lFlags, pCtx,(IWbemServices**) pInterface);
if(sc == 0x800706d3 && !t_Local) // RPC_S_UNKNOWN_AUTHN_SERVICE
{ // If we are going to a stand alone dcom box, try again with the authentication level lowered
ERRORTRACE((LOG_WBEMPROX,"Attempt to connect to %S returned RPC_S_UNKNOWN_AUTHN_SERVICE\n",NetworkResource)); HRESULT hr; hr = SetInterfaceSecurityAuth(m_pLevel1, &authident, false); if (SUCCEEDED(hr)) hr = m_pLevel1->NTLMLogin(NetworkResource, Locale, lFlags, pCtx, (IWbemServices**)pInterface); if(hr == S_OK) { SetInterfaceSecurityAuth((IUnknown *)*pInterface, &authident, false); } } else if(SUCCEEDED(sc) && bAuthenticate == false && !t_Local) {
// this is used to support share level boxs. The scripting code is written to expect that
// the IWbemServices pointer is ready to use and so it must be lowered before returning.
WbemSetProxyBlanket(*pInterface, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL, RPC_C_AUTHN_LEVEL_NONE, RPC_C_IMP_LEVEL_IDENTIFY, NULL, EOAC_NONE); }
if(FAILED(sc)) ERRORTRACE((LOG_WBEMPROX,"NTLMLogin resulted in hr = 0x%x\n", sc)); return sc;}
struct WaitThreadArg{ DWORD m_dwThreadId; HANDLE m_hTerminate;};
DWORD WINAPI TimeoutThreadRoutine(LPVOID lpParameter){
WaitThreadArg * pReq = (WaitThreadArg *)lpParameter; DWORD dwRet = WaitForSingleObject(pReq->m_hTerminate, 60000); if(dwRet == WAIT_TIMEOUT) { HRESULT hr = CoInitializeEx(NULL,COINIT_MULTITHREADED ); if(FAILED(hr)) return 1; ICancelMethodCalls * px = NULL; hr = CoGetCancelObject(pReq->m_dwThreadId, IID_ICancelMethodCalls, (void **)&px); if(SUCCEEDED(hr)) { hr = px->Cancel(0); px->Release(); } CoUninitialize(); } return 0;}
//***************************************************************************
//
// DoCCI
//
// DESCRIPTION:
//
// Connects up to WBEM via DCOM. But before making the call, a thread cancel
// thread may be created to handle the case where we try to connect up
// to a box which is hanging
//
// PARAMETERS:
//
// NetworkResource Namespze path
// ppLogin set to Login proxy
// bLocal Indicates if connection is local
// lFlags Mainly used for WBEM_FLAG_CONNECT_USE_MAX_WAIT flag
//
// RETURN VALUE:
//
// S_OK all is well
// else error listed in WBEMSVC.H
//
//***************************************************************************
SCODE CDCOMTrans::DoCCI (IN COSERVERINFO * psi, IN BOOL bLocal, long lFlags ){
if(lFlags & WBEM_FLAG_CONNECT_USE_MAX_WAIT) { // special case. we want to spawn off a thread that will kill of our
// request if it takes too long
WaitThreadArg arg; arg.m_hTerminate = CreateEvent(NULL, FALSE, FALSE, NULL); if(arg.m_hTerminate == NULL) return WBEM_E_OUT_OF_MEMORY; CCloseMe cm(arg.m_hTerminate); arg.m_dwThreadId = GetCurrentThreadId();
DWORD dwIDLikeIcare; HRESULT hr = CoEnableCallCancellation(NULL); if(FAILED(hr)) return hr; HANDLE hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)TimeoutThreadRoutine, (LPVOID)&arg, 0, &dwIDLikeIcare); if(hThread == NULL) { CoDisableCallCancellation(NULL); return WBEM_E_OUT_OF_MEMORY; } CCloseMe cm2(hThread); hr = DoActualCCI (psi, bLocal, lFlags & ~WBEM_FLAG_CONNECT_USE_MAX_WAIT ); CoDisableCallCancellation(NULL); SetEvent(arg.m_hTerminate); WaitForSingleObject(hThread, INFINITE); return hr; } else return DoActualCCI (psi, bLocal, lFlags );}
//***************************************************************************
//
// DoActualCCI
//
// DESCRIPTION:
//
// Connects up to WBEM via DCOM.
//
// PARAMETERS:
//
// NetworkResource Namespze path
// ppLogin set to Login proxy
// bLocal Indicates if connection is local
// lFlags Not used
//
// RETURN VALUE:
//
// S_OK all is well
// else error listed in WBEMSVC.H
//
//***************************************************************************
SCODE CDCOMTrans::DoActualCCI (IN COSERVERINFO * psi, IN BOOL bLocal, long lFlags ){ HRESULT t_Result ; MULTI_QI mqi;
mqi.pIID = &IID_IWbemLevel1Login; mqi.pItf = 0; mqi.hr = 0;
t_Result = CoCreateInstanceEx ( CLSID_WbemLevel1Login, NULL, CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER, ( bLocal ) ? NULL : psi , 1, &mqi );
if ( t_Result == S_OK ) { m_pLevel1 = (IWbemLevel1Login*) mqi.pItf ; DEBUGTRACE((LOG_WBEMPROX,"ConnectViaDCOM, CoCreateInstanceEx resulted in hr = 0x%x\n", t_Result )); } else { ERRORTRACE((LOG_WBEMPROX,"ConnectViaDCOM, CoCreateInstanceEx resulted in hr = 0x%x\n", t_Result )); }
return t_Result ;}
|
