397 lines
11 KiB
C++
397 lines
11 KiB
C++
//=--------------------------------------------------------------------------=
|
|
// ClassF.Cpp
|
|
//=--------------------------------------------------------------------------=
|
|
// Copyright 1995-1996 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
|
|
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|
|
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
|
|
// PARTICULAR PURPOSE.
|
|
//=--------------------------------------------------------------------------=
|
|
//
|
|
// contains the implementation of the ClassFactory object. we support
|
|
// IClassFactory and IClassFactory2
|
|
//
|
|
#include "IPServer.H"
|
|
#include "LocalSrv.H"
|
|
|
|
#include "ClassF.H"
|
|
#include "Globals.H"
|
|
#include "Unknown.H" // for CREATEFNOFOBJECT
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// private module level data
|
|
//=--------------------------------------------------------------------------=
|
|
//
|
|
|
|
// ASSERT and FAIL require this
|
|
//
|
|
SZTHISFILE
|
|
|
|
// private routines for this file
|
|
//
|
|
HRESULT CreateOleObjectFromIndex(IUnknown *, int Index, void **, REFIID);
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::CClassFactory
|
|
//=--------------------------------------------------------------------------=
|
|
// create the object and initialize the refcount
|
|
//
|
|
// Parameters:
|
|
// int - [in] index into our global table of objects for this guy
|
|
//
|
|
// Notes:
|
|
//
|
|
CClassFactory::CClassFactory
|
|
(
|
|
int iIndex
|
|
)
|
|
: m_iIndex(iIndex)
|
|
{
|
|
m_cRefs = 1;
|
|
}
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::CClassFactory
|
|
//=--------------------------------------------------------------------------=
|
|
// "Life levels all men. Death reveals the eminent."
|
|
// - George Bernard Shaw (1856 - 1950)
|
|
//
|
|
// Notes:
|
|
//
|
|
CClassFactory::~CClassFactory ()
|
|
{
|
|
ASSERT(m_cRefs == 0, "Object being deleted with refs!");
|
|
return;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::QueryInterface
|
|
//=--------------------------------------------------------------------------=
|
|
// the user wants another interface. we won't give 'em. very many.
|
|
//
|
|
// Parameters:
|
|
// REFIID - [in] interface they want
|
|
// void ** - [out] where they want to put the resulting object ptr.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_NOINTERFACE
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CClassFactory::QueryInterface
|
|
(
|
|
REFIID riid,
|
|
void **ppvObjOut
|
|
)
|
|
{
|
|
void *pv;
|
|
|
|
CHECK_POINTER(ppvObjOut);
|
|
|
|
// we support IUnknown, and the two CF interfaces
|
|
//
|
|
if (DO_GUIDS_MATCH(riid, IID_IClassFactory)) {
|
|
pv = (void *)(IClassFactory *)this;
|
|
} else if (DO_GUIDS_MATCH(riid, IID_IClassFactory2)) {
|
|
pv = (void *)(IClassFactory2 *)this;
|
|
} else if (DO_GUIDS_MATCH(riid, IID_IUnknown)) {
|
|
pv = (void *)(IUnknown *)this;
|
|
} else {
|
|
*ppvObjOut = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
((IUnknown *)pv)->AddRef();
|
|
*ppvObjOut = pv;
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::AddRef
|
|
//=--------------------------------------------------------------------------=
|
|
// adds a tick to the current reference count.
|
|
//
|
|
// Output:
|
|
// ULONG - the new reference count
|
|
//
|
|
// Notes:
|
|
//
|
|
ULONG CClassFactory::AddRef
|
|
(
|
|
void
|
|
)
|
|
{
|
|
return ++m_cRefs;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::Release
|
|
//=--------------------------------------------------------------------------=
|
|
// removes a tick from the count, and delets the object if necessary
|
|
//
|
|
// Output:
|
|
// ULONG - remaining refs
|
|
//
|
|
// Notes:
|
|
//
|
|
ULONG CClassFactory::Release
|
|
(
|
|
void
|
|
)
|
|
{
|
|
ASSERT(m_cRefs, "No Refs, and we're being released!");
|
|
if(--m_cRefs)
|
|
return m_cRefs;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::CreateInstance
|
|
//=--------------------------------------------------------------------------=
|
|
// create an instance of some sort of object.
|
|
//
|
|
// Parameters:
|
|
// IUnknown * - [in] controlling IUknonwn for aggregation
|
|
// REFIID - [in] interface id for new object
|
|
// void ** - [out] pointer to new interface object.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_NOINTERFACE, E_UNEXPECTED,
|
|
// E_OUTOFMEMORY, E_INVALIDARG
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CClassFactory::CreateInstance
|
|
(
|
|
IUnknown *pUnkOuter,
|
|
REFIID riid,
|
|
void **ppvObjOut
|
|
)
|
|
{
|
|
// check args
|
|
//
|
|
if (!ppvObjOut)
|
|
return E_INVALIDARG;
|
|
|
|
// check to see if we've done our licensing work. we do this as late
|
|
// as possible that people calling CreateInstanceLic don't suffer from
|
|
// a performance hit here.
|
|
//
|
|
// crit sect this for apartment threading, since it's global
|
|
//
|
|
EnterCriticalSection(&g_CriticalSection);
|
|
if (!g_fCheckedForLicense) {
|
|
g_fMachineHasLicense = CheckForLicense();
|
|
g_fCheckedForLicense = TRUE;
|
|
}
|
|
LeaveCriticalSection(&g_CriticalSection);
|
|
|
|
// check to see if they have the appropriate license to create this stuff
|
|
//
|
|
if (!g_fMachineHasLicense)
|
|
return CLASS_E_NOTLICENSED;
|
|
|
|
// try to create one of the objects that we support
|
|
//
|
|
return CreateOleObjectFromIndex(pUnkOuter, m_iIndex, ppvObjOut, riid);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::LockServer
|
|
//=--------------------------------------------------------------------------=
|
|
// lock the server so we can't unload
|
|
//
|
|
// Parameters:
|
|
// BOOL - [in] TRUE means addref, false means release lock count.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_FAIL, E_OUTOFMEMORY, E_UNEXPECTED
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CClassFactory::LockServer
|
|
(
|
|
BOOL fLock
|
|
)
|
|
{
|
|
// update the lock count. crit sect these in case of another thread.
|
|
//
|
|
if (fLock)
|
|
InterlockedIncrement(&g_cLocks);
|
|
else {
|
|
ASSERT(g_cLocks, "D'oh! Lock Counting Problem");
|
|
InterlockedDecrement(&g_cLocks);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::GetLicInfo
|
|
//=--------------------------------------------------------------------------=
|
|
// IClassFactory2 GetLicInfo
|
|
//
|
|
// Parameters:
|
|
// LICINFO * - unclear
|
|
//
|
|
// Output:
|
|
// HRESULT - unclear
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CClassFactory::GetLicInfo
|
|
(
|
|
LICINFO *pLicInfo
|
|
)
|
|
{
|
|
CHECK_POINTER(pLicInfo);
|
|
|
|
pLicInfo->cbLicInfo = sizeof(LICINFO);
|
|
|
|
// This says whether RequestLicKey will work
|
|
//
|
|
pLicInfo->fRuntimeKeyAvail = g_fMachineHasLicense;
|
|
|
|
// This says whether the standard CreateInstance will work
|
|
//
|
|
pLicInfo->fLicVerified = g_fMachineHasLicense;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::RequestLicKey
|
|
//=--------------------------------------------------------------------------=
|
|
// IClassFactory2 RequestLicKey
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] reserved
|
|
// BSTR * - [out] unclear
|
|
//
|
|
// Output:
|
|
// HRESULT - unclear
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CClassFactory::RequestLicKey
|
|
(
|
|
DWORD dwReserved,
|
|
BSTR *pbstr
|
|
)
|
|
{
|
|
// if the machine isn't licensed, then we're not about to give this to them !
|
|
//
|
|
if (!g_fMachineHasLicense)
|
|
return CLASS_E_NOTLICENSED;
|
|
|
|
*pbstr = GetLicenseKey();
|
|
return (*pbstr) ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CClassFactory::CreateInstanceLic
|
|
//=--------------------------------------------------------------------------=
|
|
// create a new instance given a licensing key, etc ...
|
|
//
|
|
// Parameters:
|
|
// IUnknown * - [in] controlling IUnknown for aggregation
|
|
// IUnknown * - [in] reserved, must be NULL
|
|
// REFIID - [in] IID We're looking for.
|
|
// BSTR - [in] license key
|
|
// void ** - [out] where to put the new object.
|
|
//
|
|
// Output:
|
|
// HRESULT - unclear
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CClassFactory::CreateInstanceLic
|
|
(
|
|
IUnknown *pUnkOuter,
|
|
IUnknown *pUnkReserved,
|
|
REFIID riid,
|
|
BSTR bstrKey,
|
|
void **ppvObjOut
|
|
)
|
|
{
|
|
*ppvObjOut = NULL;
|
|
|
|
// go and see if the key they gave us matches.
|
|
//
|
|
if (!CheckLicenseKey(bstrKey))
|
|
return CLASS_E_NOTLICENSED;
|
|
|
|
// if it does, then go and create the object.
|
|
//
|
|
return CreateOleObjectFromIndex(pUnkOuter, m_iIndex, ppvObjOut, riid);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// CreateOleObjectFromIndex
|
|
//=--------------------------------------------------------------------------=
|
|
// given an index in our object table, create an object from it.
|
|
//
|
|
// Parameters:
|
|
// IUnknown * - [in] Controlling Unknown, if any, for aggregation
|
|
// int - [in] index into our global table
|
|
// void ** - [out] where to put resulting object.
|
|
// REFIID - [in] the interface they want resulting object to be.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_OUTOFMEMORY, E_NOINTERFACE
|
|
//
|
|
// Notes:
|
|
//
|
|
HRESULT CreateOleObjectFromIndex
|
|
(
|
|
IUnknown *pUnkOuter,
|
|
int iIndex,
|
|
void **ppvObjOut,
|
|
REFIID riid
|
|
)
|
|
{
|
|
IUnknown *pUnk = NULL;
|
|
HRESULT hr;
|
|
|
|
// go and create the object
|
|
//
|
|
ASSERT(CREATEFNOFOBJECT(iIndex), "All creatable objects must have creation fn!");
|
|
pUnk = CREATEFNOFOBJECT(iIndex)(pUnkOuter);
|
|
|
|
// sanity check and make sure the object actually got allocated.
|
|
//
|
|
RETURN_ON_NULLALLOC(pUnk);
|
|
|
|
// make sure we support aggregation here properly -- if they gave us
|
|
// a controlling unknown, then they -must- ask for IUnknown, and we'll
|
|
// give them the private unknown the object gave us.
|
|
//
|
|
if (pUnkOuter) {
|
|
if (!DO_GUIDS_MATCH(riid, IID_IUnknown)) {
|
|
pUnk->Release();
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
*ppvObjOut = (void *)pUnk;
|
|
hr = S_OK;
|
|
} else {
|
|
|
|
// QI for whatever the user wants.
|
|
//
|
|
hr = pUnk->QueryInterface(riid, ppvObjOut);
|
|
pUnk->Release();
|
|
RETURN_ON_FAILURE(hr);
|
|
}
|
|
|
|
return hr;
|
|
}
|