able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/wmi/wbem/winmgmt/stdprov/provauto.cpp

1651 lines
41 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) 1996-2001 Microsoft Corporation
Module Name:
PROVAUTO.CPP
Abstract:
Defines the acutal "Put" and "Get" functions for the
Automation provider. The syntax of the mapping string is;
"[path],[classid]|property
History:
a-davj 3-13-96 Created.
--*/
NOTE, THE ORIGINAL SERVER2.CPP HAS CODE TO INITIALIZE gpStorage and ghAutoMutex
#include "precomp.h"
#include "stdafx.h"
#include <wbemidl.h>
#include "afxpriv.h"
#include "provauto.h"
#include "cvariant.h"
#define NOTFOUND -1
extern TCHAR * gpStorageFile;
extern CMyDLL theApp;
//////////////////////////////////////////////////////////////////////////////
// Special automation version of CHandleCache which also stores a hidden window,
// site and path information. The hidden window also contains a COleContainer
// object. Note that this extra information is only used by OCXs. The various
// values are freed up by the CImpAuto::Free routine and so a destructor isnt
// needed for this class.
//***************************************************************************
//
// CAutoCache::CAutoCache
//
// DESCRIPTION:
//
// Constructor.
//
//***************************************************************************
CAutoCache::CAutoCache ()
{
pSavePath = NULL;
pSite = NULL;
pCtlWnd = NULL;
}
//***************************************************************************
//
// SCODE CImpAuto::DoCall
//
// DESCRIPTION:
//
// Makes an IDispath Invoke call.
//
// PARAMETERS:
//
// wOpt
// ProvObj
// iIndex
// pDisp
// vt
// pData
// pProp
//
// RETURN VALUE:
// Return: True if OK. If there is a problem, then the error code is set
// in pMo in addition to having a FALSE return code.
//
//
//***************************************************************************
SCODE CImpAuto::DoCall(
WORD wOpt,
CProvObj & ProvObj,
int iIndex,
LPDISPATCH pDisp,
VARTYPE vt,
void * pData,
WCHAR * pProp)
{
USES_CONVERSION;
DISPID dispid;
SCODE sc;
COleDispatchDriver Disp;
BYTE cArgTypes[MAX_ARGS+2]; // Extra for null terminator and for Put value
void * Args[MAX_ARGS+1]; // Extra for put value
int iNumArgs = 0,iExp;
// Get the dispatch ID for property/method name
OLECHAR * pArg;
if(pProp == NULL)
pArg = T2OLE(ProvObj.sGetToken(iIndex));
else
pArg = pProp;
sc = pDisp->GetIDsOfNames(IID_NULL,&pArg,1,LOCALE_SYSTEM_DEFAULT,
&dispid);
if (sc != S_OK)
return sc;
// Get the arguments, if any, ready for the call
memset(cArgTypes,0,MAX_ARGS+2);
iNumArgs = ProvObj.iGetNumExp(iIndex);
if(iNumArgs > MAX_ARGS)
{
return WBEM_E_FAILED; // too many arguments
}
for(iExp = 0; iExp < iNumArgs; iExp++)
{
// if the argument is a string, then create a BSTR and point to it. If the
// argument is an integer, just typecast it into the argument array
if(ProvObj.IsExpString(iIndex,iExp))
{
Args[iExp] = SysAllocString(T2OLE(ProvObj.sGetStringExp(iIndex,iExp)));
if(Args[iExp] == NULL)
{
sc = WBEM_E_OUT_OF_MEMORY;
goto DoInvokeCleanup;
}
cArgTypes[iExp] = VT_BSTR;
}
else
{
cArgTypes[iExp] = VT_I4;
Args[iExp] = (void *)ProvObj.iGetIntExp(iIndex,iExp,0);
}
}
// use the MFC automation driver to do the acual invoke
Disp.AttachDispatch(pDisp);
TRY
{
if((wOpt & DISPATCH_PROPERTYPUT) || (wOpt & DISPATCH_PROPERTYPUTREF))
{
cArgTypes[iNumArgs] = (BYTE)vt;
Args[iNumArgs] = pData;
Disp.InvokeHelper(dispid,wOpt,VT_EMPTY,NULL,cArgTypes,
Args[0],Args[1],Args[2],Args[3],Args[4],Args[5]);
}
else
Disp.InvokeHelper(dispid,wOpt,vt,pData,cArgTypes,
Args[0],Args[1],Args[2],Args[3],Args[4],Args[5]);
sc = S_OK;
}
CATCH(CException, e)
{
sc = WBEM_E_FAILED;
}
END_CATCH
Disp.DetachDispatch();
// This is used to clean up any BSTR strings that might have been allocated. This
// can be skipped if it fails before any of the strings are allocated.
DoInvokeCleanup:
for(iExp = 0; iExp < iNumArgs; iExp++)
if(cArgTypes[iExp] == VT_BSTR)
SysFreeString((BSTR)Args[iExp]);
return sc;
}
//***************************************************************************
//
// SCODE CImpAuto::GetCFileStreamObj
//
// DESCRIPTION:
//
// Some OCXs use a persistent stream to load and save data. This
// routine gets a COleStreamFile object for such proposes.
//
// PARAMETERS:
//
// pPath
// ppStorage
// **ppFile
// *pCache
//
// RETURN VALUE:
//
//
//***************************************************************************
SCODE CImpAuto::GetCFileStreamObj(
const TCHAR * pPath,
LPSTORAGE * ppStorage,
COleStreamFile **ppFile,
CAutoCache *pCache)
{
SCODE sc;
USES_CONVERSION;
*ppStorage = NULL;
*ppFile = NULL;
if(pPath == NULL) // Some OCXs dont need storage, this is OK.
return S_OK;
// Save Path in the cache
ASSERT(pCache->pSavePath == NULL);
pCache->pSavePath = new TCHAR[lstrlen(pPath) + 1];
lstrcpy(pCache->pSavePath,pPath);
// During first run after install, the compond file will not exist. This
// is not as a problem as it will be created during the write
sc = StgIsStorageFile(T2OLE(gpStorageFile));
if(sc == STG_E_FILENOTFOUND)
return S_OK;
if(sc != S_OK)
{ // unusual failure!
return sc;
}
// Open up the root storage. It should never fail since we just checked to make
// sure the file is available.
// TODO, might want to mutex control access to the storage
sc = StgOpenStorage(T2OLE(gpStorageFile),NULL,STGM_READ|STGM_SHARE_DENY_WRITE,
NULL,0l,ppStorage);
if(FAILED(sc))
{
return WBEM_E_FAILED;
}
// Create a new COleStreamFile object and set the stream using the storage object.
*ppFile = new COleStreamFile();
if(*ppFile == NULL)
{
return WBEM_E_OUT_OF_MEMORY;
}
// Open a stream. Note that failure isnt unusual since this might be the
// first time for the control.
COleStreamFile * pFile = *ppFile;
if(!pFile->OpenStream(*ppStorage,pPath,STGM_READ|STGM_SHARE_EXCLUSIVE))
{
delete *ppFile;
*ppFile = NULL;
}
return S_OK;
}
//***************************************************************************
//
// BOOL CImpAuto::bIsControl
//
// DESCRIPTION:
//
// tests if the IUnknown is pointing to an object which is an OCX.
//
// PARAMETERS:
//
// lpTest
//
// RETURN VALUE:
//
//
//***************************************************************************
BOOL CImpAuto::bIsControl(
LPUNKNOWN lpTest)
{
LPOLECONTROL lpCont = NULL;
SCODE sc = lpTest->QueryInterface(IID_IOleControl,(LPVOID *) & lpCont);
if(FAILED(sc) || lpCont == NULL)
return FALSE;
// Have an OCX, free up the pointer for now since it will be retireved by
// the COleControlSite object later on
lpCont->Release();
return TRUE;
}
//***************************************************************************
//
// SCODE CImpAuto::ParsePathClass
//
// DESCRIPTION:
//
// Takes in a string in the sMix argument which is of the same for
// as the arguments to VB's GetObject and parses the string. This routine
// retrieves the path and class strings and determines the type. This could be;
// "path","class" (Type BOTH) or
// "path" (Type PATH) or
// "","class" (Type NEWCLASS) or
// ,"class" (Type RUNNINGCLASS)
//
// PARAMETERS:
//
// sMix
// sPath
// sClass
// type
//
// RETURN VALUE:
//
//
//***************************************************************************
SCODE CImpAuto::ParsePathClass(
const CString & sMix,
CString & sPath,
CString & sClass,
OBJTYPE * type)
{
int iLen = sMix.GetLength();
int iFstst = NOTFOUND; // first quote of the first string
int iFsten = NOTFOUND; // last quote of the last string
int iSecst = NOTFOUND; // first quote of the second string
int iSecen = NOTFOUND; // last quote of the second string
int iCommaPos = NOTFOUND; // position of comma between strings
int iIndex;
int iNumSoFar = 0; // number of '"' found so far
// Go through the string and find the starting and ending '"' of the path string
// and possibly the class string. Note the location of the comma.
for(iIndex = 0; iIndex < iLen; iIndex++)
{
if(sMix[iIndex] == DQUOTE)
{
iNumSoFar++;
if(iFstst == NOTFOUND && iCommaPos == NOTFOUND)
iFstst = iIndex;
if(iCommaPos == NOTFOUND)
iFsten = iIndex;
if(iSecst == NOTFOUND && iCommaPos != NOTFOUND)
iSecst = iIndex;
if(iCommaPos != NOTFOUND)
iSecen = iIndex;
}
if(sMix[iIndex] == SEPARATOR && (iNumSoFar%2 == 0) && iCommaPos == NOTFOUND)
iCommaPos = iIndex;
}
// Verify that there were an even number of quotes.
if(iNumSoFar%2 || iNumSoFar == 0)
{
return WBEM_E_FAILED; // odd number of quotes is bad
}
// Extract the strings.
for(iIndex = iFstst+1; iIndex < iFsten; iIndex++)
{
sPath += sMix[iIndex];
// if there is a "" in the string, copy just the first
if(sMix[iIndex] == DQUOTE)
iIndex++;
}
for(iIndex = iSecst+1; iIndex < iSecen; iIndex++)
{
sClass += sMix[iIndex];
// if there is a "" in the string, copy just the first
if(sMix[iIndex] == DQUOTE)
iIndex++;
}
// make sure that something was retrieved!
if(sPath.GetLength() < 1 && sClass.GetLength() < 1)
{
return WBEM_E_FAILED; // didnt get any data!
}
// figure out what type of request
if(sPath.GetLength() > 0 && sClass.GetLength() > 0)
*type = BOTH;
else if(sPath.GetLength() > 0 && sClass.GetLength() == 0)
*type = PATH;
else if(sPath.GetLength() == 0 && sClass.GetLength() > 0 && iFstst != NOTFOUND)
*type = NEWCLASS;
else if(sPath.GetLength() == 0 && sClass.GetLength() > 0 && iFstst == NOTFOUND)
*type = RUNNINGCLASS;
else
{
return WBEM_E_FAILED; // got some sort of junk!
}
return S_OK; // all is well
}
//***************************************************************************
//
// CImpAuto::CImpAuto
//
// DESCRIPTION:
//
// Constructor.
//
// PARAMETERS:
//
// ObjectPath
// User
// Password
//
//***************************************************************************
CImpAuto::CImpAuto()
{
wcscpy(wcCLSID,L"{DAC651D1-7CC7-11cf-A5B6-00AA00680C3F}");
}
//***************************************************************************
// void CImpAuto::EndBatch
//
// DESCRIPTION:
//
// Called at the end of a batch of Refrest/Update Property calls. Free up
// any cached handles and then delete the handle cache.
//
// PARAMETERS:
//
// lFlags
// pClassInt
// *pObj
// bGet
//
// RETURN VALUE:
//
//
//***************************************************************************
void CImpAuto::EndBatch(
long lFlags,
IWbemClassObject FAR * pClassInt,
CObject *pObj,
BOOL bGet)
{
if(pObj != NULL)
{
Free(0,(CAutoCache *)pObj);
delete pObj;
}
}
//***************************************************************************
//
// void CImpAuto::Free
//
// DESCRIPTION:
//
// Frees up cached IDispatch interfaces starting with position
// iStart till the end. After freeing handles, the cache object
// member function is used to delete the cache entries.
//
// PARAMETERS:
//
// iStart
// pCache
//
// RETURN VALUE:
//
//
//***************************************************************************
void CImpAuto::Free(
int iStart,
CAutoCache * pCache)
{
int iCurr;
LPOLEOBJECT pTemp = NULL;
AFX_MANAGE_STATE(AfxGetStaticModuleState())
for(iCurr = pCache->lGetNumEntries()-1; iCurr >= iStart; iCurr--)
{
LPDISPATCH pDisp = (LPDISPATCH)pCache->hGetHandle(iCurr);
if(pDisp != NULL)
pDisp->Release();
}
pCache->Delete(iStart); // get cache to delete the entries
if(iStart == 0)
{
if(pCache->pSavePath)
{
if(pCache->pSite)
{
DWORD dwRet;
dwRet = WaitForSingleObject(ghAutoMutex,MAX_AUTO_WAIT);
if(dwRet == WAIT_ABANDONED || dwRet == WAIT_OBJECT_0)
{
try
{
StoreControl(pCache);
}
catch(...) {}
ReleaseMutex(ghAutoMutex);
}
}
delete pCache->pSavePath;
pCache->pSavePath = NULL;
}
if(pCache->pCtlWnd != NULL)
{
// DONOT delete the Site object since the Control container does it!!
// Note important HACK! There is a bug in the MFC that ships with VC 4.0.
// The COleControlSite::CreateOrLoad routine has a QueryInterface call
// to get an IPersistMemory interface, BUT DOES NOT RELEASE IT! So, to
// release it, there is a bit of code here to call release until the count
// goes to 0.
if(pCache->pSite)
{
pTemp = pCache->pSite->m_pObject;
pTemp->AddRef();
}
pCache->pCtlWnd->DestroyWindow(); // note that DestroyWindow frees up the object
pCache->pCtlWnd = NULL; // and gets rid of the container within
// First release for the AddRef right above. Second possible release is
// for the bug!
if(pCache->pSite && pTemp)
{
DWORD dwRes = pTemp->Release();
if(dwRes > 0)
pTemp->Release();
}
}
pCache->pSite = NULL;
}
}
//***************************************************************************
//
// SCODE CImpAuto::RefreshProperty
//
// DESCRIPTION:
//
// Gets the value of a single property from an automation server.
//
// PARAMETERS:
//
// lFlags
// pClassInt
// PropName
// ProvObj
// pPackage
// pVar
//
// RETURN VALUE:
//
//
//***************************************************************************
SCODE CImpAuto::RefreshProperty(
long lFlags,
IWbemClassObject FAR * pClassInt,
BSTR PropName,
CProvObj & ProvObj,
CObject * pPackage,
CVariant * pVar)
{
SCODE sc;
USES_CONVERSION;
CString sRet;
LPDISPATCH pDisp = NULL;
CAutoCache * pCache = (CAutoCache *)pPackage;
AFX_MANAGE_STATE(AfxGetStaticModuleState())
// Do a second parse on the provider string.
CProvObj ObjectPath(ProvObj.sGetFullToken(1),DOT);
sc = ObjectPath.dwGetStatus(1); //todo, is 1 ok??
if(sc != S_OK)
return sc;
// Get the IDispatch interface and then do the "Get"
int iDepth = ObjectPath.iGetNumTokens()-1;
HINSTANCE hTest = afxCurrentInstanceHandle;
pDisp = pGetDispatch(&sc,ObjectPath,ProvObj.sGetToken(0),pCache,iDepth);
if(pDisp)
{
int iLast = ObjectPath.iGetNumTokens()-1;
sc = DoCall(DISPATCH_PROPERTYGET,ObjectPath,iLast,pDisp,VT_BSTR,&sRet);
if(sc == S_OK)
{
CVariant varAuto;
sc = varAuto.SetData(T2OLE(sRet),VT_LPWSTR);
if(sc != S_OK)
return sc;
sc = varAuto.DoPut(lFlags,pClassInt,PropName,pVar);
}
}
return sc;
}
//***************************************************************************
//
// LPDISPATCH CImpAuto::pGetBoth
//
// DESCRIPTION:
//
// Gets IDISPATCH interface to the server using path and class.
//
// PARAMETERS:
//
// psc
// pPath
// pClass
// *pCache
//
// RETURN VALUE:
//
//
//***************************************************************************
LPDISPATCH CImpAuto::pGetBoth(
SCODE * psc,
const TCHAR * pPath,
const TCHAR * pClass,
CAutoCache *pCache)
{
HRESULT sc;
USES_CONVERSION;
CLSID clsid;
LPDISPATCH lpRetDispatch = NULL;
LPUNKNOWN lpUnknown = NULL;
LPPERSISTFILE lpPersist = NULL;
sc = CLSIDFromProgID(T2OLE(pClass), &clsid);
if (FAILED(sc))
goto BadBoth;
// create an instance with the IUnknown
sc = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_IUnknown, (LPVOID *)&lpUnknown);
if (FAILED(sc))
goto BadBoth;
OleRun(lpUnknown); // Some objects need this!
// If the class is an OCX, then use special code to get its value
if(bIsControl(lpUnknown))
{
DWORD dwRet;
dwRet = WaitForSingleObject(ghAutoMutex,MAX_AUTO_WAIT);
if(dwRet == WAIT_ABANDONED || dwRet == WAIT_OBJECT_0)
{
try
{
lpRetDispatch = pGetOCX(psc,pPath,clsid,pCache,lpUnknown); //frees lpUnknown
}
catch(...)
{
lpRetDispatch = NULL;
}
ReleaseMutex(ghAutoMutex);
}
else
*psc = WBEM_E_FAILED;
return lpRetDispatch;
}
// query for persist file interface
sc = lpUnknown->QueryInterface(IID_IPersistFile,(LPVOID *)&lpPersist);
lpUnknown->Release();
if (FAILED(sc))
goto BadBoth;
// do a sanity check, probably not necessary.
ASSERT(lpPersist != NULL);
if (lpPersist == NULL)
{
sc = WBEM_E_FAILED;
goto BadBoth;
}
// Load up the desired file
sc = lpPersist->Load(T2OLE(pPath),0);
if (FAILED(sc))
goto BadBoth;
sc = lpPersist->QueryInterface(IID_IDispatch,(LPVOID *)&lpRetDispatch);
lpPersist->Release();
if (FAILED(sc))
goto BadBoth;
ASSERT(lpRetDispatch != NULL);
if (lpRetDispatch != NULL)
return lpRetDispatch;
BadBoth:
if(lpPersist != NULL)
lpPersist->Release();
*psc = sc;
return NULL;
}
//***************************************************************************
//
// LPDISPATCH CImpAuto::pGetDispatch
//
// DESCRIPTION:
//
// Gets get the IDispatch for gets and sets
//
// PARAMETERS:
//
// psc
// ObjectPath
// pPathClass
// *pCache
// iDepth
//
// RETURN VALUE:
//
//
//***************************************************************************
LPDISPATCH CImpAuto::pGetDispatch(
SCODE * psc,
CProvObj & ObjectPath,
LPCTSTR pPathClass,
CAutoCache *pCache,
int iDepth)
{
LPDISPATCH pRetDisp;
int iNumSkip;
int iIndex;
// Get at least the application interface. If the object path is in common with
// previous calls, then some of the subobject are already set and that is
// indicated by the value in iNumSkip;
pRetDisp = pGetDispatchRoot(psc,ObjectPath,pPathClass,pCache,iNumSkip);
// For each subobject that wasnt in the cache, get its IDispatch, and add it
// to the cache.
for(iIndex = iNumSkip; iIndex < iDepth && pRetDisp; iIndex++)
{
LPDISPATCH pNewDisp;
*psc = DoCall(DISPATCH_PROPERTYGET,ObjectPath,iIndex,
pRetDisp,VT_DISPATCH,&pNewDisp);
if(*psc != S_OK)
return NULL;
*psc = pCache->lAddToList(ObjectPath.sGetFullToken(iIndex),pNewDisp);
if(*psc != S_OK)
return NULL;
pRetDisp = pNewDisp;
}
return pRetDisp;
}
//***************************************************************************
//
// LPDISPATCH CImpAuto::pGetDispatchRoot
//
// DESCRIPTION:
//
// Gets the interface to the application object or some other starting point
// such as a "document" object.
//
// PARAMETERS:
//
// psc
// ObjectPath
// pPathClass
// *pCache
// iNumSkip
//
// RETURN VALUE:
//
//
//***************************************************************************
LPDISPATCH CImpAuto::pGetDispatchRoot(
SCODE * psc,
CProvObj & ObjectPath,
LPCTSTR pPathClass,
CAutoCache *pCache,
int & iNumSkip)
{
iNumSkip = 0;
LPDISPATCH pRetDisp = NULL;
OBJTYPE type;
HKEY hRoot = NULL;
const TCHAR * pObject = ObjectPath.sGetFullToken(0);
if(pPathClass == NULL || pObject == NULL)
{
*psc = WBEM_E_FAILED; // bad mapping string
return NULL;
}
// If there are handles in the cache, then they may be used if and
// only if the path/class matches.
if(pCache->lGetNumEntries() > 0)
{
if(lstrcmpi(pCache->sGetString(0),pPathClass))
// The path/class has changed.free all the cached handles.
Free(0,pCache);
else
{
// The Path/class matches what is in the cache. Determine how much
// else is in common, free what isnt in common, and return
// the subkey share a common path.
iNumSkip = pCache->lGetNumMatch(1,0,ObjectPath);
Free(1+iNumSkip,pCache);
return (LPDISPATCH )pCache->hGetHandle(iNumSkip);
}
}
// Need to get the initial IDispatch handle. Start off by breaking up
// path/class string. Note that TRY/CATCH is used since
// bParsePathClass does CString allocations which can give exceptions.
CString sPath,sClass;
TRY
{
*psc = ParsePathClass(pPathClass,sPath,sClass,&type);
if(*psc != S_OK)
return NULL; // bad string, actual error set in bParsePathClass
}
CATCH(CException, e)
{
*psc = WBEM_E_OUT_OF_MEMORY;
return NULL;
}
END_CATCH
// Based on the path/class combination, call the correct routine to
// actually hook up to the server.
switch(type)
{
case BOTH:
pRetDisp = pGetBoth(psc,sPath,sClass,pCache);
break;
case PATH:
pRetDisp = pGetPath(psc,sPath);
break;
case NEWCLASS:
pRetDisp = pGetNewClass(psc,sClass,pCache);
break;
case RUNNINGCLASS:
pRetDisp = pGetRunningClass(psc,sClass,pCache);
break;
default:
*psc = WBEM_E_FAILED;
}
if(pRetDisp == NULL)
return NULL;
// Got the initial IDispatch interface. Add it to the Cache
*psc = pCache->lAddToList(pPathClass,pRetDisp);
if(*psc != S_OK)
{ // error adding to cache, probably memory
pRetDisp->Release();
return NULL;
}
return pRetDisp; // all is well!
}
//***************************************************************************
//
// LPDISPATCH CImpAuto::pGetNewClass
//
// DESCRIPTION:
//
// Gets IDISPATCH interface to the server using the class id and always
// creates a new object.
//
// PARAMETERS:
//
// psc
// pClass
// *pCache
//
// RETURN VALUE:
//
//
//***************************************************************************
LPDISPATCH CImpAuto::pGetNewClass(
SCODE * psc,
const TCHAR * pClass,
CAutoCache *pCache)
{
HRESULT sc;
CLSID clsid;
USES_CONVERSION;
LPDISPATCH lpRetDispatch = NULL;
LPUNKNOWN lpUnknown = NULL;
sc = CLSIDFromProgID(T2OLE(pClass), &clsid);
if (FAILED(sc))
goto BadNewClass;
// create an instance with the IUnknown
sc = CoCreateInstance(clsid, NULL, CLSCTX_ALL, IID_IUnknown, (LPVOID *)&lpUnknown);
if (FAILED(sc))
goto BadNewClass;
OleRun(lpUnknown);
// If the class is an OCX, then use special code to get its value
if(bIsControl(lpUnknown))
{
DWORD dwRet;
dwRet = WaitForSingleObject(ghAutoMutex,MAX_AUTO_WAIT);
if(dwRet == WAIT_ABANDONED || dwRet == WAIT_OBJECT_0)
{
try
{
lpRetDispatch = pGetOCX(psc,NULL,clsid,pCache,lpUnknown); //frees lpUnknown
}
catch(...)
{ lpRetDispatch = NULL;
}
ReleaseMutex(ghAutoMutex);
}
else
*psc = WBEM_E_FAILED;
return lpRetDispatch;
}
// query for IDispatch interface
sc = lpUnknown->QueryInterface(IID_IDispatch,(LPVOID *)&lpRetDispatch);
lpUnknown->Release();
if (FAILED(sc))
goto BadNewClass;
ASSERT(lpRetDispatch != NULL);
return lpRetDispatch;
BadNewClass:
*psc = sc;
return NULL;
}
//***************************************************************************
//
// LPDISPATCH CImpAuto::pGetOCX
//
// DESCRIPTION:
//
// Gets IDISPATCH interface to an OCX. Note that the lpUnk should be
// released at the end of the routine so that the server will
// continue running even as it is setup as a control!
//
// PARAMETERS:
//
// psc
// pPath
// clsid
// *pCache
// lpUnk
//
// RETURN VALUE:
//
//
//***************************************************************************
LPDISPATCH CImpAuto::pGetOCX(
SCODE * psc,
const TCHAR * pPath,
CLSID & clsid,
CAutoCache *pCache,
LPUNKNOWN lpUnk)
{
RECT rect;
rect.left = 0; rect.right = 150; rect.top = 0; rect.bottom = 150;
LPDISPATCH lpRetDispatch = NULL;
COleControlContainer * pCont = NULL;
BOOL bOK;
SCODE sc;
LPSTORAGE pStorage = NULL;
COleStreamFile * pFileStream = NULL;
// Possibly create a COleStreamFile object. This is done only if the pPath is
// not NULL and if everything exists. This routine must release the pStorage
// interface and the pFileStream objects if the are created!
*psc = GetCFileStreamObj(pPath, &pStorage, &pFileStream,pCache);
if(*psc != S_OK)
goto EndpGetOCX;
// Create the window that will contain the controls. The window's contstructor
// creates the COleContainer object.
pCache->pCtlWnd = new CCtlWnd();
if(pCache->pCtlWnd == NULL)
{
*psc = WBEM_E_OUT_OF_MEMORY;
goto EndpGetOCX;
}
pCont = pCache->pCtlWnd->pGetCont();
// Do quick sanity check, shouldnt fail
if(pCont == NULL)
{
*psc = WBEM_E_FAILED;
goto EndpGetOCX;
}
// Use the control container to create the site and control in one call
bOK = pCont->CreateControl(NULL, clsid, NULL,WS_CHILD,
rect, 23, pFileStream, FALSE,
NULL, &pCache->pSite);
if(!bOK || pCache->pSite == NULL)
{
pCache->pSite = NULL;
*psc = WBEM_E_FAILED;
goto EndpGetOCX;
}
// query for IDispatch interface
sc = pCache->pSite->m_pObject->QueryInterface(IID_IDispatch,
(LPVOID *)&lpRetDispatch);
if (FAILED(sc))
{
*psc = sc;
lpRetDispatch = NULL;
}
EndpGetOCX:
if(pFileStream)
{
pFileStream->Close();
delete pFileStream;
}
if(pStorage)
pStorage->Release();
if(lpUnk)
lpUnk->Release();
return lpRetDispatch;
}
//***************************************************************************
//
// LPDISPATCH CImpAuto::pGetPath
//
// DESCRIPTION:
//
// Gets IDISPATCH interface to the server using the path.
//
// PARAMETERS:
//
// psc
// pPath
//
// RETURN VALUE:
//
//
//***************************************************************************
LPDISPATCH CImpAuto::pGetPath(
SCODE * psc,
const TCHAR * pPath)
{
HRESULT sc;
LPBC pbc=NULL;
LPDISPATCH lpRetDispatch = NULL;
USES_CONVERSION;
LPMONIKER pmk;
pmk=NULL;
DWORD dwEat;
// Get a bind context object.
sc = CreateBindCtx(0, &pbc);
if (FAILED(sc))
{
*psc = sc;
return NULL;
}
// Get a moniker
sc = MkParseDisplayName(pbc, T2OLE(pPath), &dwEat, &pmk);
if (FAILED(sc))
goto BadPath;
// Bind the moniker
sc = (pmk)->BindToObject(pbc, NULL, IID_IDispatch
, (void **)&lpRetDispatch);
pmk->Release();
if(FAILED(sc))
goto BadPath;
ASSERT(lpRetDispatch != NULL);
// If the class is an OCX, then something is wrong here.
if(bIsControl(lpRetDispatch))
{
*psc = WBEM_E_FAILED;
lpRetDispatch->Release();
return NULL;
}
if(lpRetDispatch)
{ // should always be true at this point!
pbc->Release();
return lpRetDispatch;
}
sc = WBEM_E_FAILED;
BadPath:
if(pbc)
pbc->Release();
*psc = sc;
return NULL;
}
//***************************************************************************
//
// LPDISPATCH CImpAuto::pGetRunningClass
//
// DESCRIPTION:
//
// Gets IDISPATCH interface to the server using the class id and always
// returns only running objects.
//
// PARAMETERS:
//
// psc
// pClass
// *pCache
//
// RETURN VALUE:
//
//
//***************************************************************************
LPDISPATCH CImpAuto::pGetRunningClass(
SCODE * psc,
const TCHAR * pClass,
CAutoCache *pCache)
{
HRESULT sc;
CLSID clsid;
LPDISPATCH lpRetDispatch = NULL;
USES_CONVERSION;
LPUNKNOWN lpUnknown = NULL;
sc = CLSIDFromProgID(T2OLE(pClass), &clsid);
if (FAILED(sc))
goto BadRunningClass;
// create an instance with the IUnknown
sc = GetActiveObject(clsid,NULL,&lpUnknown);
if (FAILED(sc))
goto BadRunningClass;
// query for IDispatch interface
sc = lpUnknown->QueryInterface(IID_IDispatch,(LPVOID *)&lpRetDispatch);
lpUnknown->Release();
if (FAILED(sc))
goto BadRunningClass;
// If the class is an OCX, then use special code to get its value
if(bIsControl(lpUnknown))
return pGetOCX(psc,NULL,clsid,pCache,lpUnknown); //frees lpUnknown
ASSERT(lpRetDispatch != NULL);
if (lpRetDispatch != NULL)
return lpRetDispatch;
BadRunningClass:
*psc = sc;
return NULL;
}
//***************************************************************************
//
// SCODE CImpAuto::UpdateProperty
//
// DESCRIPTION:
//
// Writes the value of a single property to an automation server.
//
// PARAMETERS:
//
// lFlags
// pClassInt
// PropName
// ProvObj
// pPackage
// pVar
//
// RETURN VALUE:
//
//
//***************************************************************************
SCODE CImpAuto::UpdateProperty(
long lFlags,
IWbemClassObject FAR * pClassInt,
BSTR PropName,
CProvObj & ProvObj,
CObject * pPackage,
CVariant * pVar)
{
CVariant vIn;
SCODE sc;
AFX_MANAGE_STATE(AfxGetStaticModuleState())
// Get the property value
if(pClassInt)
{
sc = pClassInt->Get(PropName,lFlags,vIn.GetVarPtr(),NULL,NULL);
if(sc != S_OK)
return sc;
sc = vIn.ChangeType(VT_BSTR);
}
else if(pVar)
{
sc =OMSVariantChangeType(vIn.GetVarPtr(), pVar->GetVarPtr(),0, VT_BSTR);
}
else
sc = WBEM_E_FAILED;
if(sc != S_OK)
return sc;
LPDISPATCH pDisp = NULL;
CAutoCache * pCache = (CAutoCache *)pPackage;
// Do a second parse on the provider string.
CProvObj ObjectPath(ProvObj.sGetFullToken(1),DOT);
sc = ObjectPath.dwGetStatus(1);
if(sc != S_OK)
return sc;
// Get the IDispatch interface and then do the "Get"
int iDepth = ObjectPath.iGetNumTokens()-1;
pDisp = pGetDispatch(&sc,ObjectPath,ProvObj.sGetToken(0),pCache,iDepth);
if(pDisp)
{
int iLast = ObjectPath.iGetNumTokens()-1;
sc = DoCall(DISPATCH_PROPERTYPUT,ObjectPath,iLast,pDisp,VT_BSTR,vIn.GetBstr());
}
return sc;
}
//***************************************************************************
//
// SCODE CImpAuto::StartBatch
//
// DESCRIPTION:
//
// Called at the start of a batch of Refrest/Update Property calls. Initialize
// the handle cache.
//
// PARAMETERS:
//
// lFlags
// pClassInt
// **pObj
// bGet
//
// RETURN VALUE:
//
//
//***************************************************************************
SCODE CImpAuto::StartBatch(
long lFlags,
IWbemClassObject FAR * pClassInt,
CObject **pObj,
BOOL bGet)
{
*pObj = new CAutoCache;
return (pObj != NULL) ? S_OK : WBEM_E_OUT_OF_MEMORY;
}
//***************************************************************************
//
// void CImpAuto::StoreControl
//
// DESCRIPTION:
//
// Used when an OCX is no longer being used and the OCX uses
// a stream to store its data.
//
// PARAMETERS:
//
// *pCache
//
//***************************************************************************
void CImpAuto::StoreControl(
CAutoCache *pCache)
{
SCODE sc;
LPSTORAGE pIStorage = NULL;
LPSTREAM pIStream = NULL;
LPPERSISTSTREAMINIT pPersStm = NULL;
USES_CONVERSION;
// Open up the storage file, create it if necessary
sc = StgIsStorageFile(T2OLE(gpStorageFile));
if(sc == S_OK)
sc = StgOpenStorage(T2OLE(gpStorageFile),NULL,
STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
NULL,0L, &pIStorage);
else if(sc == STG_E_FILENOTFOUND)
sc = StgCreateDocfile(T2OLE(gpStorageFile),
STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE,
0L, &pIStorage);
if(sc != S_OK)
return; //todo, error handling?????
// Open/Create the stream
sc = pIStorage->OpenStream(T2OLE(pCache->pSavePath),NULL,
STGM_READWRITE|STGM_SHARE_EXCLUSIVE,
0,&pIStream);
if(sc == STG_E_FILENOTFOUND)
sc = pIStorage->CreateStream(T2OLE(pCache->pSavePath),
STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_FAILIFTHERE,
0,0,&pIStream);
if(sc != S_OK)
{
goto cleanupStoreControl;
}
sc = pCache->pSite->m_pObject->QueryInterface(IID_IPersistStreamInit,
(void **)&pPersStm);
if(!FAILED(sc))
pPersStm->Save(pIStream,TRUE);
cleanupStoreControl:
if(pPersStm)
pPersStm->Release();
if(pIStream)
pIStream->Release();
if(pIStorage)
pIStorage->Release();
}
/////////////////////////////////////////////////////////////////////////////////
// Special version of CWnd which is used to hold OCXs. It automatically sets
// itself up as an OCX container and it also has a function to return pointer
// to the control container.
//***************************************************************************
//
// CCtlWnd::CCtlWnd
//
// DESCRIPTION:
//
// Constructor.
//
//***************************************************************************
CCtlWnd::CCtlWnd()
{
RECT rect; rect.left = 0; rect.right = 50; rect.bottom = 100; rect.top = 0;
AfxEnableControlContainer();
HANDLE hh = afxCurrentInstanceHandle;
hh = AfxGetInstanceHandle();
Create(NULL,"");
InitControlContainer();
}
//***************************************************************************
//
// SCODE CImpAuto::MakeEnum
//
// DESCRIPTION:
//
// Creates a CEnumPerfInfo object which can be used for enumeration
//
// PARAMETERS:
//
// pClass
// ProvObj
// ppInfo
//
// RETURN VALUE:
//
//
//***************************************************************************
SCODE CImpAuto::MakeEnum(
IWbemClassObject * pClass,
CProvObj & ProvObj,
CEnumInfo ** ppInfo)
{
SCODE sc;
*ppInfo = NULL;
LPDISPATCH pDisp = NULL;
CAutoCache Cache;
AFX_MANAGE_STATE(AfxGetStaticModuleState())
// Do a second parse on the provider string.
CProvObj ObjectPath(ProvObj.sGetFullToken(1),DOT);
sc = ObjectPath.dwGetStatus(1); //todo, is 1 ok??
if(sc != S_OK)
return sc;
// Get the IDispatch interface and then get thedo the "Get"
int iDepth = ObjectPath.iGetNumTokens();
pDisp = pGetDispatch(&sc,ObjectPath,ProvObj.sGetToken(0),&Cache,iDepth);
if(pDisp)
{
int iCount;
sc = DoCall(DISPATCH_PROPERTYGET,ObjectPath,0,pDisp,VT_I4,
&iCount,L"Count");
if(sc == S_OK)
{
// Create a new CEnumAutoInfo object.
CEnumAutoInfo * pInfo = new CEnumAutoInfo(iCount);
if(pInfo == NULL)
{
sc = WBEM_E_OUT_OF_MEMORY;
}
else
*ppInfo = pInfo;
}
}
return sc;
}
//***************************************************************************
//
// SCODE CImpAuto::GetKey
//
// DESCRIPTION:
//
//
// PARAMETERS:
//
// pInfo
// iIndex
// ppKey
//
// RETURN VALUE:
//
//
//***************************************************************************
SCODE CImpAuto::GetKey(
CEnumInfo * pInfo,
int iIndex,
LPWSTR * ppKey)
{
*ppKey = new WCHAR[10];
CEnumAutoInfo * pAuto = (CEnumAutoInfo *)pInfo;
if(iIndex >= pAuto->GetCount())
return WBEM_E_FAILED;
if(*ppKey == NULL)
return WBEM_E_OUT_OF_MEMORY;
_itow(iIndex + 1,*ppKey,10);
return S_OK;
}
//***************************************************************************
//
// SCODE CImpAuto::MergeStrings
//
// DESCRIPTION:
//
// Combines the Class Context, Key, and Property Context strings.
//
// PARAMETERS:
//
// ppOut
// pClassContext
// pKey
// pPropContext
//
// RETURN VALUE:
//
//
//***************************************************************************
SCODE CImpAuto::MergeStrings(
LPWSTR * ppOut,
LPWSTR pClassContext,
LPWSTR pKey,
LPWSTR pPropContext)
{
// Allocate space for output
int iLen = 6;
if(pClassContext)
iLen += wcslen(pClassContext);
if(pKey)
iLen += wcslen(pKey);
if(pPropContext)
iLen += wcslen(pPropContext);
else
return WBEM_E_FAILED; // should always have this!
*ppOut = new WCHAR[iLen];
if(*ppOut == NULL)
return WBEM_E_OUT_OF_MEMORY;
// simple case is that everything is in the property context. That would
// be the case when the provider is being used as a simple dynamic
// property provider
if(pClassContext == NULL || pKey == NULL)
{
wcscpy(*ppOut,pPropContext);
return S_OK;
}
// Copy the class context, property, and finally the key
wcscpy(*ppOut,pClassContext);
wcscat(*ppOut,L"(");
wcscat(*ppOut,pKey);
wcscat(*ppOut,L").");
wcscat(*ppOut,pPropContext);
return S_OK;
}
//***************************************************************************
//
// CEnumAutoInfo::CEnumAutoInfo
//
// DESCRIPTION:
//
// Constructor.
//
// PARAMETERS:
//
// iCount
//
//***************************************************************************
CEnumAutoInfo::CEnumAutoInfo(
int iCount)
{
m_iCount = iCount;
}
//***************************************************************************
//
// CEnumAutoInfo::~CEnumAutoInfo
//
// DESCRIPTION:
//
// Destructor.
//
//***************************************************************************
CEnumAutoInfo::~CEnumAutoInfo()
{
}
//***************************************************************************
//
// CImpAutoProp::CImpAutoProp
//
// DESCRIPTION:
//
// Constructor.
//
//***************************************************************************
CImpAutoProp::CImpAutoProp()
{
m_pImpDynProv = new CImpAuto();
}
//***************************************************************************
//
// CImpAutoProp::~CImpAutoProp
//
// DESCRIPTION:
//
// Destructor.
//
//***************************************************************************
CImpAutoProp::~CImpAutoProp()
{
if(m_pImpDynProv)
delete m_pImpDynProv;
}
Reference in a new issue Copy permalink