dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/admin/wmi/wbem/sdk/samples/nondistrib/incidenttracker/msa/msa.cpp
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

1058 lines
29 KiB
C++
Raw Blame History

// msa.cpp : Defines the class behaviors for the application.
//
// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
//
#include <wbemidl.h>
#include "stdafx.h"
#include "msa.h"
#include "consfactory.h"
#include "sinkobject.h"
#include "activatesink.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CMsaApp
BEGIN_MESSAGE_MAP(CMsaApp, CWinApp)
//{{AFX_MSG_MAP(CMsaApp)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG
ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMsaApp construction
CMsaApp::CMsaApp()
{
m_pNamespace = NULL;
for(int i = 0; i < 20; i++)
m_pObjSink[i] = NULL;
m_bRegistered = false;
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CMsaApp object
CMsaApp theApp;
bool g_bProviding = false;
/////////////////////////////////////////////////////////////////////////////
// CMsaApp initialization
BOOL CMsaApp::InitInstance()
{
HRESULT hr;
BOOL regEmpty = FALSE; // did a self-unregister happen?
CConsumerFactory *m_consumerFactory = NULL;
if(SUCCEEDED(CoInitialize(NULL)))
hr = CoInitializeSecurity(NULL, -1, NULL, NULL,
RPC_C_AUTHN_LEVEL_CONNECT,
RPC_C_IMP_LEVEL_IDENTIFY, NULL, 0, 0);
else
{
AfxMessageBox(_T("CoInitialize Failed"));
return FALSE;
}
// Check the command line
TCHAR tcTemp[128];
TCHAR seps[] = _T(" ");
TCHAR *token = NULL;
WCHAR wcTemp[128];
BSTR bstrConnect = SysAllocString(L"\\\\.\\root\\sampler");
_tcscpy(tcTemp, (LPCTSTR)m_lpCmdLine);
token = _tcstok( tcTemp, seps );
while( token != NULL )
{
if((_tcscmp(token, _T("/CONNECT")) == 0) || (_tcscmp(token, _T("/connect")) == 0))
{
token = _tcstok( NULL, seps );
MultiByteToWideChar (CP_OEMCP, MB_PRECOMPOSED, token, (-1),
wcTemp, 128);
SysFreeString(bstrConnect);
bstrConnect = SysAllocString(wcTemp);
}
/* Get next token: */
token = _tcstok( NULL, seps );
}
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
IWbemServices *pNamespace = NULL;
IWbemClassObject *pObj1 = NULL;
IEnumWbemClassObject *pEnum = NULL;
ULONG uReturned;
BSTR bstrPassword = SysAllocString(L"RelpMas1");
BSTR bstrTargetNamespace = SysAllocString(L"TargetNamespace");
VARIANT v;
VariantInit(&v);
// Create a dialog to appease the user durring log on
CDialog *ldlg = new CDialog(IDD_LOAD_DIALOG, NULL);
m_pMainWnd = ldlg;
int bWorked = ldlg->Create(IDD_LOAD_DIALOG, NULL);
// Create our main window so we ca work with it
CMsaDlg *dlg = new CMsaDlg(NULL, (void *)this);
// Let's create our user account...
if(FAILED(hr = CreateUser()))
TRACE(_T("* Creating User: %s\n"), ErrorString(hr));
// Get a namespace pointer
m_pNamespace = CheckNamespace(bstrConnect);
if(m_pNamespace != NULL)
m_bstrNamespace = SysAllocString(bstrConnect);
else
TRACE(_T("* No Namespace Connection @ App\n"));
BSTR bstrNSQuery = SysAllocString(L"smpl_msaregistration");
m_pNamespace->CreateInstanceEnum(bstrNSQuery, 0, NULL, &pEnum);
WCHAR wcUser[100];
WCHAR *pwcTmp = wcUser;
BSTR bstrUser;
wcscpy(wcUser, m_bstrNamespace);
while(*pwcTmp == L'\\')
{ pwcTmp++; }
if(*pwcTmp == L'.')
{
char cBuf[50];
DWORD dwSize = 50;
WCHAR wcUser[100];
GetComputerName(cBuf, &dwSize);
MultiByteToWideChar (CP_OEMCP, MB_PRECOMPOSED, cBuf, (-1), wcUser, 128);
wcscat(wcUser, L"\\sampler");
bstrUser = SysAllocString(wcUser);
}
else
{
WCHAR *pEnd = pwcTmp;
while(*pEnd != L'\\')
{ pEnd++; }
*pEnd = NULL;
wcscat(pwcTmp, L"\\sampler");
bstrUser = SysAllocString(pwcTmp);
}
SetInterfaceSecurity(pNamespace, NULL, bstrUser, bstrPassword);
int i = 0;
while(S_OK == (hr = pEnum->Next(INFINITE, 1, &pObj1, &uReturned)))
{
if(FAILED(pObj1->Get(bstrTargetNamespace, 0, &v, NULL, NULL)))
TRACE(_T("* SelfProvide.Unable to get namespace"));
pNamespace = CheckNamespace(V_BSTR(&v));
VariantClear(&v);
if(pNamespace != NULL)
{
// Get an object sink
if(SUCCEEDED(hr = pNamespace->QueryObjectSink(0, &m_pObjSink[i])))
{
m_bRegistered = true;
i++;
}
else
TRACE(_T("* Error retrieving sink %s\n"), ErrorString(hr));
}
else
TRACE(_T("* No Namespace Connection @ App\n"));
pNamespace = NULL;
}
m_pMainWnd = NULL;
delete ldlg;
m_pMainWnd = dlg;
dlg->DoModal();
delete dlg;
void *pTmp;
CancelItem *pSinkItem;
IWbemServices *pTmpNS = NULL;
IWbemServices *pSamplerCancelNamespace = NULL;
// Cleanup Cancel List
while(!m_CancelList.IsEmpty())
{
pTmp = m_CancelList.RemoveTail();
pSinkItem = (CancelItem *)pTmp;
pTmpNS = CheckNamespace(pSinkItem->bstrNamespace);
if(pTmpNS != NULL)
{
pTmpNS->QueryInterface(IID_IWbemServices, (void **)&pSamplerCancelNamespace);
pSamplerCancelNamespace->CancelAsyncCall(pSinkItem->pSink);
pSamplerCancelNamespace->Release();
pSamplerCancelNamespace = NULL;
}
delete pSinkItem;
}
// Cleanup The Magic List
void *pTheItem;
while(!m_JunkList.IsEmpty())
{
pTheItem = m_JunkList.RemoveTail();
delete pTheItem;
}
while(!m_NamespaceList.IsEmpty())
{
pTheItem = m_NamespaceList.RemoveTail();
delete pTheItem;
}
if(m_pNamespace != NULL)
m_pNamespace->Release();
i = 0;
while(m_pObjSink[i] != NULL)
{
m_pObjSink[i]->Release();
i++;
}
CoRevokeClassObject(m_clsConsReg);
CoRevokeClassObject(m_clsDistReg);
CoUninitialize();
SysFreeString(bstrTargetNamespace);
SysFreeString(bstrUser);
SysFreeString(bstrPassword);
return FALSE;
}
HRESULT CMsaApp::ActivateNotification(CMsaDlg *dlg)
{
HRESULT hr = WBEM_E_FAILED;
IWbemServices *pNSSampler = NULL;
BSTR bstrNamespace = SysAllocString(L"\\\\.\\root\\sampler");
// Get a namespace pointer
pNSSampler = CheckNamespace(bstrNamespace);
if(pNSSampler != NULL)
{
CActiveSink *pActSink = new CActiveSink(this, pNSSampler, dlg);
hr = pNSSampler->ExecQueryAsync(SysAllocString(L"WQL"),
SysAllocString(L"select * from Smpl_Observation"), 0, NULL, pActSink);
TRACE(_T("* Notification Complete: %s\n"), ErrorString(hr));
AddToJunkList(pActSink);
}
else
TRACE(_T("* Skipping Notification\n"));
SysFreeString(bstrNamespace);
return hr;
}
HRESULT CMsaApp::CreateUser(void)
{
HRESULT hr;
VARIANT v;
IWbemServices *pSecurity = NULL;
IWbemClassObject *pClass = NULL;
IWbemLocator *pLocator = NULL;
IWbemClassObject *pObj = NULL;
BSTR bstrNamespace = SysAllocString(L"\\\\.\\root\\security");
BSTR bstrNTLMUser = SysAllocString(L"__NTLMUser");
BSTR bstrSERVER = SysAllocString(L"__SERVER");
BSTR bstrName = SysAllocString(L"Name");
BSTR bstrDomain = SysAllocString(L"Domain");
BSTR bstrPermissions = SysAllocString(L"Permissions");
BSTR bstrEnabled = SysAllocString(L"Enabled");
BSTR bstrExecuteMethods = SysAllocString(L"ExecuteMethods");
VariantInit(&v);
// Get a namespace pointer
// We aren't using CheckNamespace because we don't know if the user
// has been created. If not, CheckNamespace will break.
if(SUCCEEDED(hr = CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER,
IID_IWbemLocator, (void **)&pLocator)))
{
if(FAILED(hr = pLocator->ConnectServer(bstrNamespace, NULL, NULL, NULL,
0, NULL, NULL, &pSecurity)))
{
TRACE(_T("* Unable to connect to Namespace root\\security: %s\n"),
ErrorString(hr));
return hr;
}
SetInterfaceSecurity(pSecurity, NULL, NULL, NULL);
pLocator->Release();
}
else
{
TRACE(_T("* Failed to create Locator object: %s\n"), ErrorString(hr));
return hr;
}
// Now we will create th user
if(SUCCEEDED(hr = pSecurity->GetObject(bstrNTLMUser, 0, NULL, &pClass, NULL)))
{
hr = pClass->Get(bstrSERVER, 0, &v, NULL, NULL);
hr = pClass->SpawnInstance(0, &pObj);
pClass->Release();
// We still have the server name in here
hr = pObj->Put(bstrDomain, 0, &v, NULL);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = SysAllocString(L"sampler");
hr = pObj->Put(bstrName, 0, &v, NULL);
VariantClear(&v);
V_VT(&v) = VT_I4;
V_I4(&v) = 2;
hr = pObj->Put(bstrPermissions, 0, &v, NULL);
VariantClear(&v);
V_VT(&v) = VT_BOOL;
V_BOOL(&v) = TRUE;
hr = pObj->Put(bstrEnabled, 0, &v, NULL);
VariantClear(&v);
V_VT(&v) = VT_BOOL;
V_BOOL(&v) = TRUE;
hr = pObj->Put(bstrExecuteMethods, 0, &v, NULL);
VariantClear(&v);
if(FAILED(pSecurity->PutInstance(pObj, WBEM_FLAG_CREATE_OR_UPDATE,
NULL, NULL)))
AfxMessageBox(_T("Error: Unable to create user account\nOnly local access will be possible"));
pObj->Release();
}
SysFreeString(bstrNamespace);
SysFreeString(bstrNTLMUser);
SysFreeString(bstrSERVER);
SysFreeString(bstrName);
SysFreeString(bstrDomain);
SysFreeString(bstrPermissions);
SysFreeString(bstrEnabled);
SysFreeString(bstrExecuteMethods);
return hr;
}
///////////////////////////////////////////////////////
// AddToNamespaceList //
//---------------------------------------------------//
// Adds an item to the Namespace list for later //
// retreival. This is to reduce the number of //
// Namespace pointer requests to a minimum. //
///////////////////////////////////////////////////////
void CMsaApp::AddToNamespaceList(BSTR bstrNamespace, IWbemServices *pNewNamespace)
{
NamespaceItem *pTheItem = new NamespaceItem;
pTheItem->bstrNamespace = SysAllocString(bstrNamespace);
pNewNamespace->QueryInterface(IID_IWbemServices, (void **)&pTheItem->pNamespace);
m_NamespaceList.AddTail(pTheItem);
}
///////////////////////////////////////////////////////
// AddToJunkList //
//---------------------------------------------------//
// Adds an item to the Namespace list for later //
// retreival. This is to reduce the number of //
// Namespace pointer requests to a minimum. //
///////////////////////////////////////////////////////
void CMsaApp::AddToJunkList(void *pTheItem)
{
m_JunkList.AddTail(pTheItem);
}
///////////////////////////////////////////////////////
// AddToCancelList //
//---------------------------------------------------//
// Adds an item to the Cancelation list for later //
// retreival. //
///////////////////////////////////////////////////////
void CMsaApp::AddToCancelList(void *pTheItem)
{
m_CancelList.AddTail(pTheItem);
}
///////////////////////////////////////////////////////
// CheckNamespace //
//---------------------------------------------------//
// Checks to see if a namespace change is required, //
// and if it is performs the necessary change. //
///////////////////////////////////////////////////////
IWbemServices * CMsaApp::CheckNamespace(BSTR wcItemNS)
{
int iSize;
POSITION pPos;
NamespaceItem *pTheItem;
BSTR bstrNamespace = SysAllocString(wcItemNS);
WCHAR *pwcStart = wcItemNS;
WCHAR *pwcEnd;
WCHAR wcNewNS[200];
BSTR bstrUser;
char cBuffer[200];
DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
WCHAR wcTemp[MAX_COMPUTERNAME_LENGTH + 1];
int iBufSize = 200;
// Parse the namespace to get the user and get it in a consistent format
while(*pwcStart == L'\\')
{ pwcStart++; }
if(*pwcStart == L'.')
{
GetComputerName(cBuffer, &dwSize);
MultiByteToWideChar (CP_OEMCP, MB_PRECOMPOSED, cBuffer, (-1),
wcTemp, 128);
pwcStart++;
wcscpy(wcNewNS, L"\\\\");
wcscat(wcNewNS, wcTemp);
wcscat(wcNewNS, pwcStart);
bstrNamespace = SysAllocString(wcNewNS);
wcscpy(wcItemNS, wcTemp);
wcscat(wcItemNS, L"\\sampler");
bstrUser = SysAllocString(wcItemNS);
}
else
{
pwcEnd = pwcStart;
while(*pwcEnd != L'\\')
{ pwcEnd++; }
*pwcEnd = NULL;
wcscat(pwcStart, L"\\sampler");
bstrUser = SysAllocString(pwcStart);
}
iSize = m_NamespaceList.GetCount();
for(int iPos = 0; iPos < iSize; iPos++)
{
pPos = m_NamespaceList.FindIndex(iPos);
void *pTmp = m_NamespaceList.GetAt(pPos);
pTheItem = (NamespaceItem *)pTmp;
if(0 == wcscmp(bstrNamespace, pTheItem->bstrNamespace))
return pTheItem->pNamespace;
}
IWbemServices *pNamespace = NULL;
pNamespace = ConnectNamespace(bstrNamespace, bstrUser);
// If we succeeded add it to the list
if(pNamespace != NULL)
AddToNamespaceList(bstrNamespace, pNamespace);
SysFreeString(bstrUser);
SysFreeString(bstrNamespace);
return pNamespace;
}
///////////////////////////////////////////////////////
// ConnectNamespace //
//---------------------------------------------------//
// Connects to the specified namespace using default//
// security. //
///////////////////////////////////////////////////////
IWbemServices * CMsaApp::ConnectNamespace(WCHAR *wcNamespace, WCHAR *wcUser)
{
HRESULT hr;
IWbemLocator *pLocator = NULL;
IWbemServices *pNamespace = NULL;
BSTR bstrNamespace = SysAllocString(wcNamespace);
BSTR bstrUser = SysAllocString(wcUser);
BSTR bstrPassword = SysAllocString(L"RelpMas1");
char cBuffer[100];
int iBufSize = 100;
if(SUCCEEDED(hr = CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER,
IID_IWbemLocator, (void **)&pLocator)))
{
if(FAILED(hr = pLocator->ConnectServer(bstrNamespace,
bstrUser, bstrPassword, NULL, 0, NULL, NULL, &pNamespace)))
{
WideCharToMultiByte(CP_OEMCP, 0, bstrNamespace, (-1), cBuffer,
iBufSize, NULL, NULL);
TRACE(_T("* Unable to connect to Namespace %s: %s\n"), cBuffer, ErrorString(hr));
return NULL;
}
else
{
WideCharToMultiByte(CP_OEMCP, 0, bstrNamespace, (-1), cBuffer,
iBufSize, NULL, NULL);
TRACE(_T("* Connected to Namespace %s: %s\n"), cBuffer, ErrorString(hr));
SetInterfaceSecurity(pNamespace, NULL, bstrUser, bstrPassword);
}
pLocator->Release();
}
else
{
TRACE(_T("* Failed to create Locator object: %s\n"), ErrorString(hr));
return NULL;
}
SysFreeString(bstrNamespace);
SysFreeString(bstrUser);
SysFreeString(bstrPassword);
return pNamespace;
}
HRESULT CMsaApp::SelfProvideEvent(IWbemClassObject *pObj, WCHAR* wcServerNamespace,
BSTR bstrType)
{
IWbemClassObject *pNewInst = NULL;
IWbemClassObject *pClass = NULL;
VARIANT v, vDisp;
WCHAR dbuffer [9];
WCHAR tbuffer [9];
WCHAR wcTimeStamp[19];
HRESULT hr;
BSTR bstrSmplIncident = SysAllocString(L"Smpl_Incident");
TRACE(_T("* SelfProvideEvent called\n"));
VariantInit(&v);
VariantInit(&vDisp);
if(!m_bRegistered)
{
TRACE(_T("* Not connected to namespace\n"));
return WBEM_E_FAILED;
}
_wstrdate(dbuffer);
_wstrtime(tbuffer);
wcscpy(wcTimeStamp, dbuffer);
wcscat(wcTimeStamp, L" ");
wcscat(wcTimeStamp, tbuffer);
// Get the Smpl_Incident class
if(SUCCEEDED(hr = m_pNamespace->GetObject(bstrSmplIncident, 0, NULL, &pClass, NULL)))
{
// Spawn an instance for population
if(SUCCEEDED(hr = pClass->SpawnInstance(0, &pNewInst)))
{
// Put the Event (as an IDispatch *) into the new instance
BSTR bstrEvt = SysAllocString(L"TheEvent");
V_VT(&vDisp) = VT_DISPATCH;
V_DISPATCH(&vDisp) = (IDispatch *)pObj;
if(FAILED(hr = pNewInst->Put(bstrEvt, 0, &vDisp, NULL)))
TRACE(_T("* Put(TheEvent) Failed %s\n"), ErrorString(hr));
SysFreeString(bstrEvt);
// Put the incident type into the new instance
BSTR bstrIncTyp = SysAllocString(L"IncidentType");
VariantClear(&v);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = SysAllocString(bstrType);
if(FAILED(hr = pNewInst->Put(bstrIncTyp, 0, &v, NULL)))
TRACE(_T("* Put(IncidentType) Failed %s\n"), ErrorString(hr));
SysFreeString(bstrIncTyp);
// Get the time stamp and put it in the new instance
BSTR bstrIncTim = SysAllocString(L"TimeOfIncident");
VariantClear(&v);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = wcTimeStamp;
if(FAILED(hr = pNewInst->Put(bstrIncTim, 0L, &v, NULL)))
TRACE(_T("* Put(TimeOfIncident) Failed %s\n"), ErrorString(hr));
SysFreeString(bstrIncTim);
// Put ServerNamespace
BSTR bstrSrvNms = SysAllocString(L"ServerNamespace");
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = SysAllocString(wcServerNamespace);
if(FAILED(hr = pNewInst->Put(bstrSrvNms, 0, &v, NULL)))
TRACE(_T("* Put(ServerNamespace) Failed %s\n"), ErrorString(hr));
SysFreeString(bstrSrvNms);
int i = 0;
while(m_pObjSink[i] != NULL)
{
// Indicate and release the object
if(FAILED(hr = m_pObjSink[i++]->Indicate(1, &pNewInst)))
TRACE(_T("* Indicate() Failed %s\n"), ErrorString(hr));
}
// A little cleanup
if(FAILED(hr = pNewInst->Release()))
TRACE(_T("* pNewInst->Release() Failed %s\n"), ErrorString(hr));
VariantClear(&v);
VariantClear(&vDisp);
}
else
TRACE(_T("* SpawnInstance(Smpl_Incident) Failed %s\n"), ErrorString(hr));
if(FAILED(hr = pClass->Release()))
TRACE(_T("* pClass->Release() Failed %s\n"), ErrorString(hr));
}
else
TRACE(_T("* Get(Smpl_Incident) Failed %s\n"), ErrorString(hr));
SysFreeString(bstrSmplIncident);
return WBEM_NO_ERROR;
}
void CMsaApp::InternalError(HRESULT hr, TCHAR *tcMsg)
{
TRACE(tcMsg, ErrorString(hr));
AfxMessageBox(_T("Error: An internal error has prevented this operation from completing."));
}
#define TCHAR_LEN_IN_BYTES(str) _tcslen(str)*sizeof(TCHAR)+sizeof(TCHAR)
//***************************************************************************
//
// SCODE DetermineLoginType
//
// DESCRIPTION:
//
// Examines the Authority and User argument and determines the authentication
// type and possibly extracts the domain name from the user arugment in the
// NTLM case. For NTLM, the domain can be at the end of the authentication
// string, or in the front of the user name, ex; "redmond\a-davj"
//
// PARAMETERS:
//
// ConnType Returned with the connection type, ie wbem, ntlm
// AuthArg Output, contains the domain name
// UserArg Output, user name
// Authority Input
// User Input
//
// RETURN VALUE:
//
// S_OK all is well
// else error listed in WBEMSVC.H
//
//***************************************************************************
SCODE CMsaApp::DetermineLoginType(BSTR & AuthArg, BSTR & UserArg,
BSTR & Authority,BSTR & User)
{
// Determine the connection type by examining the Authority string
if(!(Authority == NULL || wcslen(Authority) == 0 || !_wcsnicmp(Authority, L"NTLMDOMAIN:",11)))
return WBEM_E_INVALID_PARAMETER;
// The ntlm case is more complex. There are four cases
// 1) Authority = NTLMDOMAIN:name" and User = "User"
// 2) Authority = NULL and User = "User"
// 3) Authority = "NTLMDOMAIN:" User = "domain\user"
// 4) Authority = NULL and User = "domain\user"
// first step is to determine if there is a backslash in the user name somewhere between the
// second and second to last character
WCHAR * pSlashInUser = NULL;
if(User)
{
WCHAR * pEnd = User + wcslen(User) - 1;
for(pSlashInUser = User; pSlashInUser <= pEnd; pSlashInUser++)
if(*pSlashInUser == L'\\') // dont think forward slash is allowed!
break;
if(pSlashInUser > pEnd)
pSlashInUser = NULL;
}
if(Authority && wcslen(Authority) > 11)
{
if(pSlashInUser)
return WBEM_E_INVALID_PARAMETER;
AuthArg = SysAllocString(Authority + 11);
if(User) UserArg = SysAllocString(User);
return S_OK;
}
else if(pSlashInUser)
{
int iDomLen = pSlashInUser-User;
WCHAR cTemp[MAX_PATH];
wcsncpy(cTemp, User, iDomLen);
cTemp[iDomLen] = 0;
AuthArg = SysAllocString(cTemp);
if(wcslen(pSlashInUser+1))
UserArg = SysAllocString(pSlashInUser+1);
}
else
if(User) UserArg = SysAllocString(User);
return S_OK;
}
//***************************************************************************
//
// SCODE SetInterfaceSecurity
//
// DESCRIPTION:
//
// This routine is used by clients in order to set the identity to be used by a connection.
//
// PARAMETERS:
//
// pInterface Interface to be set
// pDomain Input, domain
// pUser Input, user name
// pPassword Input, password.
//
// RETURN VALUE:
//
// S_OK all is well
// else error listed in WBEMSVC.H
//
//***************************************************************************
HRESULT CMsaApp::SetInterfaceSecurity(IUnknown * pInterface, LPWSTR pAuthority,
LPWSTR pUser, LPWSTR pPassword)
{
SCODE sc;
if(pInterface == NULL)
return WBEM_E_INVALID_PARAMETER;
// If we are doing trivial case, just pass in a null authenication structure which is used
// if the current logged in user's credentials are OK.
if((pAuthority == NULL || wcslen(pAuthority) < 1) &&
(pUser == NULL || wcslen(pUser) < 1) &&
(pPassword == NULL || wcslen(pPassword) < 1))
return SetInterfaceSecurity(pInterface, NULL);
// If user, or Authority was passed in, the we need to create an authority argument for the login
COAUTHIDENTITY authident;
BSTR AuthArg = NULL, UserArg = NULL;
sc = DetermineLoginType(AuthArg, UserArg, pAuthority, pUser);
if(sc != S_OK)
return sc;
char szUser[MAX_PATH], szAuthority[MAX_PATH], szPassword[MAX_PATH];
// Fill in the indentity structure
if(UserArg)
{
wcstombs(szUser, UserArg, MAX_PATH);
authident.UserLength = strlen(szUser);
authident.User = (LPWSTR)szUser;
}
else
{
authident.UserLength = 0;
authident.User = 0;
}
if(AuthArg)
{
wcstombs(szAuthority, AuthArg, MAX_PATH);
authident.DomainLength = strlen(szAuthority);
authident.Domain = (LPWSTR)szAuthority;
}
else
{
authident.DomainLength = 0;
authident.Domain = 0;
}
if(pPassword)
{
wcstombs(szPassword, pPassword, MAX_PATH);
authident.PasswordLength = strlen(szPassword);
authident.Password = (LPWSTR)szPassword;
}
else
{
authident.PasswordLength = 0;
authident.Password = 0;
}
authident.Flags = SEC_WINNT_AUTH_IDENTITY_ANSI;
sc = SetInterfaceSecurity(pInterface, &authident);
if(UserArg)
SysFreeString(UserArg);
if(AuthArg)
SysFreeString(AuthArg);
return sc;
}
//***************************************************************************
//
// SCODE SetInterfaceSecurity
//
// DESCRIPTION:
//
// This routine is used by clients in order to set the identity to be used by a connection.
//
// PARAMETERS:
//
// pInterface Interface to be set
// pauthident Structure with the identity info already set.
//
// RETURN VALUE:
//
// S_OK all is well
//
//***************************************************************************
HRESULT CMsaApp::SetInterfaceSecurity(IUnknown * pInterface,
COAUTHIDENTITY * pauthident)
{
if(pInterface == NULL)
return WBEM_E_INVALID_PARAMETER;
SCODE sc;
IClientSecurity * pCliSec = NULL;
sc = pInterface->QueryInterface(IID_IClientSecurity, (void **) &pCliSec);
if(sc != S_OK)
return sc;
sc = pCliSec->SetBlanket(pInterface, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, NULL,
RPC_C_AUTHN_LEVEL_CONNECT, RPC_C_IMP_LEVEL_IDENTIFY,
pauthident,
EOAC_NONE);
pCliSec->Release();
return sc;
}
// **************************************************************************
//
// ErrorString()
//
// Description:
// Converts an HRESULT to a displayable string.
//
// Parameters:
// hr (in) - HRESULT to be converted.
//
// Returns:
// ptr to displayable string.
//
// Globals accessed:
// None.
//
// Globals modified:
// None.
//
//===========================================================================
LPCTSTR CMsaApp::ErrorString(HRESULT hr)
{
TCHAR szBuffer2[19];
static TCHAR szBuffer[24];
LPCTSTR psz;
switch(hr)
{
case WBEM_NO_ERROR:
psz = _T("WBEM_NO_ERROR");
break;
case WBEM_S_NO_MORE_DATA:
psz = _T("WBEM_S_NO_MORE_DATA");
break;
case WBEM_E_FAILED:
psz = _T("WBEM_E_FAILED");
break;
case WBEM_E_NOT_FOUND:
psz = _T("WBEM_E_NOT_FOUND");
break;
case WBEM_E_ACCESS_DENIED:
psz = _T("WBEM_E_ACCESS_DENIED");
break;
case WBEM_E_PROVIDER_FAILURE:
psz = _T("WBEM_E_PROVIDER_FAILURE");
break;
case WBEM_E_TYPE_MISMATCH:
psz = _T("WBEM_E_TYPE_MISMATCH");
break;
case WBEM_E_OUT_OF_MEMORY:
psz = _T("WBEM_E_OUT_OF_MEMORY");
break;
case WBEM_E_INVALID_CONTEXT:
psz = _T("WBEM_E_INVALID_CONTEXT");
break;
case WBEM_E_INVALID_PARAMETER:
psz = _T("WBEM_E_INVALID_PARAMETER");
break;
case WBEM_E_NOT_AVAILABLE:
psz = _T("WBEM_E_NOT_AVAILABLE");
break;
case WBEM_E_CRITICAL_ERROR:
psz = _T("WBEM_E_CRITICAL_ERROR");
break;
case WBEM_E_INVALID_STREAM:
psz = _T("WBEM_E_INVALID_STREAM");
break;
case WBEM_E_NOT_SUPPORTED:
psz = _T("WBEM_E_NOT_SUPPORTED");
break;
case WBEM_E_INVALID_SUPERCLASS:
psz = _T("WBEM_E_INVALID_SUPERCLASS");
break;
case WBEM_E_INVALID_NAMESPACE:
psz = _T("WBEM_E_INVALID_NAMESPACE");
break;
case WBEM_E_INVALID_OBJECT:
psz = _T("WBEM_E_INVALID_OBJECT");
break;
case WBEM_E_INVALID_CLASS:
psz = _T("WBEM_E_INVALID_CLASS");
break;
case WBEM_E_PROVIDER_NOT_FOUND:
psz = _T("WBEM_E_PROVIDER_NOT_FOUND");
break;
case WBEM_E_INVALID_PROVIDER_REGISTRATION:
psz = _T("WBEM_E_INVALID_PROVIDER_REGISTRATION");
break;
case WBEM_E_PROVIDER_LOAD_FAILURE:
psz = _T("WBEM_E_PROVIDER_LOAD_FAILURE");
break;
case WBEM_E_INITIALIZATION_FAILURE:
psz = _T("WBEM_E_INITIALIZATION_FAILURE");
break;
case WBEM_E_TRANSPORT_FAILURE:
psz = _T("WBEM_E_TRANSPORT_FAILURE");
break;
case WBEM_E_INVALID_OPERATION:
psz = _T("WBEM_E_INVALID_OPERATION");
break;
case WBEM_E_INVALID_QUERY:
psz = _T("WBEM_E_INVALID_QUERY");
break;
case WBEM_E_INVALID_QUERY_TYPE:
psz = _T("WBEM_E_INVALID_QUERY_TYPE");
break;
case WBEM_E_ALREADY_EXISTS:
psz = _T("WBEM_E_ALREADY_EXISTS");
break;
case WBEM_S_ALREADY_EXISTS:
psz = _T("WBEM_S_ALREADY_EXISTS");
break;
case WBEM_S_RESET_TO_DEFAULT:
psz = _T("WBEM_S_RESET_TO_DEFAULT");
break;
case WBEM_S_DIFFERENT:
psz = _T("WBEM_S_DIFFERENT");
break;
case WBEM_E_OVERRIDE_NOT_ALLOWED:
psz = _T("WBEM_E_OVERRIDE_NOT_ALLOWED");
break;
case WBEM_E_PROPAGATED_QUALIFIER:
psz = _T("WBEM_E_PROPAGATED_QUALIFIER");
break;
case WBEM_E_PROPAGATED_PROPERTY:
psz = _T("WBEM_E_PROPAGATED_PROPERTY");
break;
case WBEM_E_UNEXPECTED:
psz = _T("WBEM_E_UNEXPECTED");
break;
case WBEM_E_ILLEGAL_OPERATION:
psz = _T("WBEM_E_ILLEGAL_OPERATION");
break;
case WBEM_E_CANNOT_BE_KEY:
psz = _T("WBEM_E_CANNOT_BE_KEY");
break;
case WBEM_E_INCOMPLETE_CLASS:
psz = _T("WBEM_E_INCOMPLETE_CLASS");
break;
case WBEM_E_INVALID_SYNTAX:
psz = _T("WBEM_E_INVALID_SYNTAX");
break;
case WBEM_E_NONDECORATED_OBJECT:
psz = _T("WBEM_E_NONDECORATED_OBJECT");
break;
case WBEM_E_READ_ONLY:
psz = _T("WBEM_E_READ_ONLY");
break;
case WBEM_E_PROVIDER_NOT_CAPABLE:
psz = _T("WBEM_E_PROVIDER_NOT_CAPABLE");
break;
case WBEM_E_CLASS_HAS_CHILDREN:
psz = _T("WBEM_E_CLASS_HAS_CHILDREN");
break;
case WBEM_E_CLASS_HAS_INSTANCES:
psz = _T("WBEM_E_CLASS_HAS_INSTANCES");
break;
case WBEM_E_QUERY_NOT_IMPLEMENTED:
psz = _T("WBEM_E_QUERY_NOT_IMPLEMENTED");
break;
case WBEM_E_ILLEGAL_NULL:
psz = _T("WBEM_E_ILLEGAL_NULL");
break;
case WBEM_E_INVALID_QUALIFIER_TYPE:
psz = _T("WBEM_E_INVALID_QUALIFIER_TYPE");
break;
case WBEM_E_INVALID_PROPERTY_TYPE:
psz = _T("WBEM_E_INVALID_PROPERTY_TYPE");
break;
case WBEM_E_VALUE_OUT_OF_RANGE:
psz = _T("WBEM_E_VALUE_OUT_OF_RANGE");
break;
case WBEM_E_CANNOT_BE_SINGLETON:
psz = _T("WBEM_E_CANNOT_BE_SINGLETON");
break;
case WBEM_S_FALSE:
psz = _T("WBEM_S_FALSE");
break;
default:
_itot(hr, szBuffer2, 16);
_tcscat(szBuffer, szBuffer2);
psz = szBuffer;
break;
}
return psz;
}
Reference in New Issue View Git Blame Copy Permalink