archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/inetsrv/query/web/ixsso/ixssocf.cxx

761 lines
23 KiB
Raw Blame History

//+---------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1995 - 2000.
//
// File: ixssocf.cxx
//
// Contents: Standard IClassFactory implementation
//
// Classes: CStaticClassFactory
// CIxssoQueryCF
//
// History: 26-Feb-96 SSanu adapted from my Forms stuff
//
//----------------------------------------------------------------------
#include "pch.cxx"
#pragma hdrstop
#include "stdcf.hxx"
#include "regutil.h"
#include "ssodebug.hxx"
#include "ixsso.hxx"
#include "ixsutil.hxx"
#include <adoid.h> // ADO CLSID and IID definitions
#include <initguid.h>
// HACKHACK - this is stolen from the old sdk\inc\adoid.h header:
#define DEFINE_ADOGUID(name, l) \
DEFINE_GUID(name, l, 0, 0x10, 0x80,0,0,0xAA,0,0x6D,0x2E,0xA4)
// ADO V1.0 recordset class ID
DEFINE_ADOGUID(CLSID_CADORecordset_V1_0, 0x00000281);
#ifndef OLYMPUS_COMPONENT
#define QUERY_PROG_ID L"IXSSO.Query"
#define QUERY_PROG_ID2 L"IXSSO.Query.2"
#define QUERY_PROG_ID3 L"IXSSO.Query.3"
#define QUERY_PROG_DESC L"Indexing Service Query SSO V2."
#define QUERY_PROG_DESC3 L"Indexing Service Query SSO V3."
extern WCHAR * g_pwszProgIdQuery = QUERY_PROG_ID;
#define UTIL_PROG_ID L"IXSSO.Util"
#define UTIL_PROG_ID2 L"IXSSO.Util.2"
#define UTIL_PROG_DESC L"Indexing Service Utility SSO V2."
extern WCHAR * g_pwszProgIdUtil = UTIL_PROG_ID;
extern WCHAR * g_pwszErrorMsgFile = L"query.dll";
#define LIBID_ixsso LIBID_Cisso
#define CLSID_ixssoQuery CLSID_CissoQuery
#define CLSID_ixssoQueryEx CLSID_CissoQueryEx
#define CLSID_ixssoUtil CLSID_CissoUtil
#else
#define NLQUERY_PROG_ID L"MSSEARCH.Query"
#define NLQUERY_PROG_ID1 L"MSSEARCH.Query.1"
#define NLQUERY_PROG_DESC L"Microsoft Site Server Search Query SSO V1."
extern WCHAR * g_pwszProgIdQuery = NLQUERY_PROG_ID;
#define NLUTIL_PROG_ID L"MSSEARCH.Util"
#define NLUTIL_PROG_ID1 L"MSSEARCH.Util.1"
#define NLUTIL_PROG_DESC L"Microsoft Site Server Search Utility SSO V1."
extern WCHAR * g_pwszProgIdUtil = NLUTIL_PROG_ID;
extern WCHAR * g_pwszErrorMsgFile = L"oquery.dll";
#define LIBID_ixsso LIBID_Nlsso
#define CLSID_ixssoQuery CLSID_NlssoQuery
#define CLSID_ixssoUtil CLSID_NlssoUtil
#endif // OLYMPUS_COMPONENT
//+------------------------------------------------------------------------
//
// CStaticClassFactory Implementation
//
//-------------------------------------------------------------------------
//+---------------------------------------------------------------
//
// Member: CStaticClassFactory::QueryInterface, public
//
// Synopsis: Method of IUnknown interface
//
//----------------------------------------------------------------
STDMETHODIMP
CStaticClassFactory::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
if (!ppv)
return E_INVALIDARG;
if (riid == IID_IUnknown ||
riid == IID_IClassFactory)
{
*ppv = (IClassFactory *) this;
}
else
{
*ppv = 0;
return E_NOINTERFACE;
}
((IUnknown *)*ppv)->AddRef();
return S_OK;
}
//+---------------------------------------------------------------
//
// Member: CStaticClassFactory::AddRef, public
//
// Synopsis: Method of IUnknown interface
//
//----------------------------------------------------------------
STDMETHODIMP_(ULONG)
CStaticClassFactory::AddRef(void)
{
Win4Assert(_ulRefs);
INC_OBJECT_COUNT();
IXIncrement(_ulRefs);
ixssoDebugOut((DEB_REFCOUNTS, "[DLL] CF::AddRef: refcounts: glob %d obj %d\n",
GET_OBJECT_COUNT(), _ulRefs ));
return _ulRefs;
}
//+---------------------------------------------------------------
//
// Member: CStaticClassFactory::Release, public
//
// Synopsis: Method of IUnknown interface
//
//----------------------------------------------------------------
STDMETHODIMP_(ULONG)
CStaticClassFactory::Release(void)
{
Win4Assert(_ulRefs > 1);
IXDecrement(_ulRefs);
DEC_OBJECT_COUNT();
ixssoDebugOut((DEB_REFCOUNTS, "[DLL] CF::Release: refcounts: glob %d obj %d\n",
GET_OBJECT_COUNT(), _ulRefs ));
return _ulRefs;
}
//+---------------------------------------------------------------
//
// Member: CStaticClassFactory::LockServer, public
//
// Synopsis: Method of IClassFactory interface
//
// Notes: Since class factories based on this class are global static
// objects, this method doesn't serve much purpose.
//
//----------------------------------------------------------------
STDMETHODIMP
CStaticClassFactory::LockServer (BOOL fLock)
{
if (fLock)
INC_OBJECT_COUNT();
else
DEC_OBJECT_COUNT();
ixssoDebugOut((DEB_REFCOUNTS, "[DLL] CF::LockServer( %x ) ==> %d\n", fLock, GET_OBJECT_COUNT() ));
return NOERROR;
}
//-----------------------------------------------------------------------------
// CIxssoQueryCF Class Definition
//-----------------------------------------------------------------------------
class CIxssoQueryCF : public CStaticClassFactory
{
public:
STDMETHOD(CreateInstance)(IUnknown *pUnkOuter, REFIID iid, LPVOID FAR* ppv);
void TryInit();
void SetClsid( CLSID ssoClsid ) { _ssoClsid = ssoClsid; }
static ITypeLib * _pITypeLibIxsso;
static IClassFactory * _pIAdoRecordsetCF;
static BOOL _fAdoV15;
static CLSID _ssoClsid;
} IxssoQueryCF; //The global factory
//-----------------------------------------------------------------------------
// CIxssoUtilCF Class Definition
//-----------------------------------------------------------------------------
class CIxssoUtilCF : public CStaticClassFactory
{
public:
STDMETHOD(CreateInstance)(IUnknown *pUnkOuter, REFIID iid, LPVOID FAR* ppv);
} IxssoUtilCF; //The global factory
//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
CRITICAL_SECTION g_cs;
HINSTANCE g_hInst;
ULONG g_ulObjCount = 0; // extern to keep track of object instances
LONG g_lQryCount = 0; // BUGBGUG - debugging for obj. ref. count
LONG g_lUtlCount = 0; // BUGBGUG - debugging for obj. ref. count
ITypeLib * CIxssoQueryCF::_pITypeLibIxsso = 0;
IClassFactory * CIxssoQueryCF::_pIAdoRecordsetCF = 0;
BOOL CIxssoQueryCF::_fAdoV15 = FALSE;
CLSID CIxssoQueryCF::_ssoClsid = CLSID_ixssoQueryEx;
CTheGlobalIXSSOVariables * g_pTheGlobalIXSSOVariables = 0;
//-----------------------------------------------------------------------------
//
// Class: CLockCritSec
//
// Synopsis: Like CLock, but takes a bare CRITICAL_SECTION, not a CMutexSem
//
//-----------------------------------------------------------------------------
class CLockCritSec : INHERIT_UNWIND
{
INLINE_UNWIND(CLockCritSec);
public:
CLockCritSec( CRITICAL_SECTION & cs ) :
_cs( cs )
{
EnterCriticalSection( &_cs );
END_CONSTRUCTION( CLockCritSec );
}
~CLockCritSec( )
{
LeaveCriticalSection( &_cs );
}
private:
CRITICAL_SECTION & _cs;
};
//-----------------------------------------------------------------------------
// CIxssoQueryCF Methods
//-----------------------------------------------------------------------------
STDMETHODIMP
CIxssoQueryCF::CreateInstance(LPUNKNOWN pUnkOuter, REFIID riid, LPVOID FAR* ppvObj)
{
*ppvObj = 0;
// NTRAID#DB-NTBUG9-84743-2000/07/31-dlee IXSSO class factory object does not support COM aggregation
if (pUnkOuter)
return CLASS_E_NOAGGREGATION;
SCODE sc = E_OUTOFMEMORY;
//
// Guard against a race between TryInit and DllCanUnloadNow...
//
INC_OBJECT_COUNT();
CixssoQuery * pObj = 0;
TRANSLATE_EXCEPTIONS;
TRY
{
TryInit();
Win4Assert( 0 != _pITypeLibIxsso && 0 != _pIAdoRecordsetCF );
// create an instance of our CixssoQuery object
pObj = new CixssoQuery( _pITypeLibIxsso,
_pIAdoRecordsetCF,
_fAdoV15,
_ssoClsid );
}
CATCH( CException, e )
{
ixssoDebugOut(( DEB_ERROR,
"Creation of CixssoQuery failed (%x)\n",
e.GetErrorCode() ));
sc = e.GetErrorCode();
}
END_CATCH
UNTRANSLATE_EXCEPTIONS;
Win4Assert( 0 != _pITypeLibIxsso && 0 != _pIAdoRecordsetCF );
DEC_OBJECT_COUNT();
if (0 == pObj)
{
Win4Assert( !SUCCEEDED(sc) );
return sc;
}
#if CIDBG
LONG l = InterlockedIncrement( &g_lQryCount );
Win4Assert( l >= 1 );
#endif //CIDBG
// fetch the interface and return
sc = pObj->QueryInterface(riid, ppvObj);
pObj->Release(); // on failure, this will release our IXSSO object
// otherwise, object will have a ref count of 1
return sc;
}
//+---------------------------------------------------------------
//
// Member: CIxssoQueryCF::TryInit, public
//
// Synopsis: Do static initialization
//
// Notes: Do any required initialization of global objects.
//
//----------------------------------------------------------------
void CIxssoQueryCF::TryInit()
{
Win4Assert (0 != g_ulObjCount);
// Initialize any global variables needed
if ( 0 == _pITypeLibIxsso ||
0 == _pIAdoRecordsetCF ||
0 == g_pTheGlobalIXSSOVariables )
{
CLockCritSec Lock(g_cs);
// get the Type lib
if (0 == _pITypeLibIxsso)
{
SCODE sc = LoadRegTypeLib(LIBID_ixsso, 1, 0, 0x409, &_pITypeLibIxsso);
if (FAILED(sc))
sc = LoadTypeLib( OLESTR("ixsso.tlb"), &_pITypeLibIxsso);
if (FAILED(sc))
{
Win4Assert( 0 == _pITypeLibIxsso );
ixssoDebugOut(( DEB_ERROR, "Type library load failed (%x)\n", sc));
THROW(CException(sc));
}
}
// Get the ADO recordset class factory
if ( 0 == _pIAdoRecordsetCF )
{
SCODE sc = CoGetClassObject( CLSID_CADORecordset,
CLSCTX_INPROC_HANDLER |
CLSCTX_INPROC_SERVER,
0,
IID_IClassFactory,
(void **)&_pIAdoRecordsetCF );
_fAdoV15 = TRUE;
if (REGDB_E_CLASSNOTREG == sc)
{
//
// The class ID for the recordset changed in ADO V1.5. Try
// the ADO V1.0 class ID.
//
sc = CoGetClassObject( CLSID_CADORecordset_V1_0,
CLSCTX_INPROC_HANDLER |
CLSCTX_INPROC_SERVER,
0,
IID_IClassFactory,
(void **)&_pIAdoRecordsetCF );
if (SUCCEEDED(sc))
_fAdoV15 = FALSE;
}
if (FAILED(sc))
{
Win4Assert( 0 == _pIAdoRecordsetCF );
ixssoDebugOut(( DEB_ERROR, "CoGetClassObject for ADO recordset failed (%x)\n", sc));
THROW(CException(sc));
}
_pIAdoRecordsetCF->LockServer( TRUE );
}
// Initialize global variables needed by the IXSSO objects
if ( 0 == g_pTheGlobalIXSSOVariables )
{
g_pTheGlobalIXSSOVariables = new CTheGlobalIXSSOVariables();
}
}
}
//-----------------------------------------------------------------------------
// CIxssoUtilCF Methods
//-----------------------------------------------------------------------------
STDMETHODIMP
CIxssoUtilCF::CreateInstance(LPUNKNOWN pUnkOuter, REFIID riid, LPVOID FAR* ppvObj)
{
*ppvObj = 0;
// NTRAID#DB-NTBUG9-84743-2000/07/31-dlee IXSSO class factory object does not support COM aggregation
if (pUnkOuter)
return CLASS_E_NOAGGREGATION;
SCODE sc = E_OUTOFMEMORY;
//
// Guard against a race between TryInit and DllCanUnloadNow...
//
INC_OBJECT_COUNT();
CixssoUtil * pObj = 0;
TRANSLATE_EXCEPTIONS;
TRY
{
IxssoQueryCF.TryInit();
Win4Assert( 0 != CIxssoQueryCF::_pITypeLibIxsso );
// create an instance of our CixssoUtil object
pObj = new CixssoUtil( CIxssoQueryCF::_pITypeLibIxsso );
}
CATCH( CException, e )
{
ixssoDebugOut(( DEB_ERROR,
"Creation of CixssoUtil failed (%x)\n",
e.GetErrorCode() ));
sc = e.GetErrorCode();
}
END_CATCH
UNTRANSLATE_EXCEPTIONS;
Win4Assert( 0 != CIxssoQueryCF::_pITypeLibIxsso );
DEC_OBJECT_COUNT();
if (0 == pObj)
{
Win4Assert( !SUCCEEDED(sc) );
return sc;
}
#if CIDBG
LONG l = InterlockedIncrement( &g_lUtlCount );
Win4Assert( l >= 1 );
#endif //CIDBG
// fetch the interface and return
sc = pObj->QueryInterface(riid, ppvObj);
pObj->Release(); // on failure, this will release our IXSSO object
// otherwise, object will have a ref count of 1
return sc;
}
//-----------------------------------------------------------------------------
// Global Scope
//-----------------------------------------------------------------------------
#ifndef OLYMPUS_COMPONENT
const CLSID clsidCommandCreator = CLSID_CISimpleCommandCreator;
#else
//0b63e347-9ccc-11d0-bcdb-00805fccce04
extern "C" CLSID CLSID_NlCommandCreator;
#define clsidCommandCreator CLSID_NlCommandCreator
#endif // OLYMPUS_COMPONENT
CTheGlobalIXSSOVariables::CTheGlobalIXSSOVariables()
{
VariantInit(&_vtAcceptLanguageHeader);
V_VT(&_vtAcceptLanguageHeader) = VT_BSTR;
V_BSTR(&_vtAcceptLanguageHeader) = SysAllocString(OLESTR("HTTP_ACCEPT_LANGUAGE"));
HRESULT hr = CoCreateInstance( clsidCommandCreator,
0,
CLSCTX_INPROC_SERVER,
IID_ISimpleCommandCreator,
xCmdCreator.GetQIPointer() );
if ( SUCCEEDED( hr ) && xCmdCreator.GetPointer() )
xCmdCreator->QueryInterface(IID_IColumnMapperCreator,
xColumnMapperCreator.GetQIPointer());
}
//-----------------------------------------------------------------------------
// OLE and DLL Methods
//-----------------------------------------------------------------------------
void FreeResources(void)
{
CLockCritSec Lock(g_cs);
if (0 == g_ulObjCount && CIxssoQueryCF::_pIAdoRecordsetCF)
{
CIxssoQueryCF::_pIAdoRecordsetCF->LockServer( FALSE );
CIxssoQueryCF::_pIAdoRecordsetCF->Release();
CIxssoQueryCF::_pIAdoRecordsetCF = 0;
}
if (0 == g_ulObjCount && CIxssoQueryCF::_pITypeLibIxsso)
{
CIxssoQueryCF::_pITypeLibIxsso->Release();
CIxssoQueryCF::_pITypeLibIxsso = 0;
}
if (0 == g_ulObjCount && g_pTheGlobalIXSSOVariables )
{
delete g_pTheGlobalIXSSOVariables;
g_pTheGlobalIXSSOVariables = 0;
}
ixssoDebugOut((DEB_REFCOUNTS, "[DLL] FreeResources -> %s\n",
(0 == g_ulObjCount) ? "S_OK" : "S_FALSE" ));
}
extern "C"
STDAPI DllCanUnloadNow(void)
{
//Our answer is whether there are any object or locks
ixssoDebugOut((DEB_REFCOUNTS,"[DLL] DllCanUnloadNow\n"));
if (0 == g_ulObjCount)
{
FreeResources();
}
return (0 == g_ulObjCount) ? S_OK : S_FALSE;
}
extern "C"
STDAPI DllRegisterServer()
{
ixssoDebugOut((DEB_TRACE,"[DLL] DllRegisterServer\n"));
SCODE sc = S_OK;
#ifndef OLYMPUS_COMPONENT
sc = _DllRegisterServer(g_hInst, QUERY_PROG_ID, CLSID_CissoQueryEx, QUERY_PROG_DESC3, QUERY_PROG_ID3);
if (SUCCEEDED(sc))
sc = _DllRegisterServer(g_hInst, QUERY_PROG_ID3, CLSID_CissoQueryEx, QUERY_PROG_DESC3);
if (SUCCEEDED(sc))
sc = _DllRegisterServer(g_hInst, QUERY_PROG_ID2, CLSID_CissoQuery, QUERY_PROG_DESC);
if (SUCCEEDED(sc))
sc = _DllRegisterServer(g_hInst, UTIL_PROG_ID, CLSID_CissoUtil, UTIL_PROG_DESC, UTIL_PROG_ID2);
if (SUCCEEDED(sc))
sc = _DllRegisterServer(g_hInst, UTIL_PROG_ID2, CLSID_CissoUtil, UTIL_PROG_DESC);
#else
sc = _DllRegisterServer(g_hInst, NLQUERY_PROG_ID, CLSID_NlssoQuery, NLQUERY_PROG_DESC, NLQUERY_PROG_ID1);
if (SUCCEEDED(sc))
sc = _DllRegisterServer(g_hInst, NLQUERY_PROG_ID1, CLSID_NlssoQuery, NLQUERY_PROG_DESC);
if (SUCCEEDED(sc))
sc = _DllRegisterServer(g_hInst, NLUTIL_PROG_ID, CLSID_NlssoUtil, NLUTIL_PROG_DESC, NLUTIL_PROG_ID1);
if (SUCCEEDED(sc))
sc = _DllRegisterServer(g_hInst, NLUTIL_PROG_ID1, CLSID_NlssoUtil, NLUTIL_PROG_DESC);
#endif
if (SUCCEEDED(sc))
{
// Register the type library
WCHAR wcsProgram[MAX_PATH+1];
ULONG cchPath = GetModuleFileName(g_hInst, wcsProgram, MAX_PATH);
XInterface<ITypeLib> xpITypeLibIxsso;
if ( 0 != cchPath )
sc = LoadTypeLib( wcsProgram, xpITypeLibIxsso.GetPPointer());
else
sc = E_FAIL;
if (SUCCEEDED(sc))
sc = RegisterTypeLib(xpITypeLibIxsso.GetPointer(), wcsProgram, 0);
if (FAILED(sc))
{
ixssoDebugOut(( DEB_ERROR, "Type library load or registration failed (%x)\n", sc));
#ifndef OLYMPUS_COMPONENT
_DllUnregisterServer(QUERY_PROG_ID3, CLSID_CissoQueryEx);
_DllUnregisterServer(QUERY_PROG_ID2, CLSID_CissoQuery);
_DllUnregisterServer(QUERY_PROG_ID, CLSID_CissoQueryEx);
_DllUnregisterServer(UTIL_PROG_ID2, CLSID_CissoUtil);
_DllUnregisterServer(UTIL_PROG_ID, CLSID_CissoUtil);
#else //OLYMPUS_COMPONENT
_DllUnregisterServer(NLQUERY_PROG_ID1, CLSID_NlssoQuery);
_DllUnregisterServer(NLQUERY_PROG_ID, CLSID_NlssoQuery);
_DllUnregisterServer(NLUTIL_PROG_ID1, CLSID_NlssoUtil);
_DllUnregisterServer(NLUTIL_PROG_ID, CLSID_NlssoUtil);
#endif //OLYMPUS_COMPONENT
}
}
return sc;
}
extern "C"
STDAPI DllUnregisterServer()
{
ixssoDebugOut((DEB_TRACE,"[DLL] DllUnregisterServer\n"));
SCODE sc;
#ifndef OLYMPUS_COMPONENT
sc = _DllUnregisterServer(QUERY_PROG_ID, CLSID_CissoQueryEx);
if (SUCCEEDED(sc))
sc = _DllUnregisterServer(QUERY_PROG_ID3, CLSID_CissoQueryEx);
if (SUCCEEDED(sc))
sc = _DllUnregisterServer(QUERY_PROG_ID2, CLSID_CissoQuery);
if (SUCCEEDED(sc))
sc = _DllUnregisterServer(UTIL_PROG_ID, CLSID_CissoUtil);
if (SUCCEEDED(sc))
sc = _DllUnregisterServer(UTIL_PROG_ID2, CLSID_CissoUtil);
#else //OLYMPUS_COMPONENT
sc = _DllUnregisterServer(NLQUERY_PROG_ID, CLSID_NlssoQuery);
if (SUCCEEDED(sc))
sc = _DllUnregisterServer(NLQUERY_PROG_ID1, CLSID_NlssoQuery);
if (SUCCEEDED(sc))
sc = _DllUnregisterServer(NLUTIL_PROG_ID, CLSID_NlssoUtil);
if (SUCCEEDED(sc))
sc = _DllUnregisterServer(NLUTIL_PROG_ID1, CLSID_NlssoUtil);
#endif //OLYMPUS_COMPONENT
return sc;
}
extern "C"
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID * ppv)
{
// get the class factory object
if ( CLSID_ixssoQueryEx == rclsid || CLSID_ixssoQuery == rclsid )
{
IxssoQueryCF.SetClsid( rclsid );
return IxssoQueryCF.QueryInterface( riid, ppv );
}
else if ( CLSID_ixssoUtil == rclsid )
{
// NOTE: There is no difference in the behavior of the Util object.
return IxssoUtilCF.QueryInterface( riid, ppv );
}
else
{
return CLASS_E_CLASSNOTAVAILABLE;
}
}
extern "C"
BOOL WINAPI DllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lbv)
{
BOOL fRetval = TRUE;
TRANSLATE_EXCEPTIONS;
TRY
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
//DbgPrint("IXSSO: [DLL] Process Attached\n");
g_hInst = hInst;
InitializeCriticalSection( &g_cs );
break;
case DLL_THREAD_DETACH:
//
// This is an opportunity to release resources; necessary since
// ASP doesn't call CoFreeUnusedLibraries.
//
ixssoDebugOut((DEB_REFCOUNTS, "[DLL] Thread detached\n"));
if (0 == g_ulObjCount)
{
FreeResources();
}
break;
case DLL_PROCESS_DETACH:
// NOTE: We can get called here without having freed resources
// if the client application is single-threaded, or if
// thread detach calls are disabled. In this case, it's
// too late to free the ADO recordset class factory because
// the ADO DLL may have already been unloaded.
#if CIDBG
if ( 0 != CIxssoQueryCF::_pIAdoRecordsetCF && 0 != g_ulObjCount )
{
ixssoDebugOut((DEB_WARN, "WARNING - %d unreleased objects\n", g_ulObjCount ));
}
#endif //CIDBG
if (CIxssoQueryCF::_pITypeLibIxsso)
{
CIxssoQueryCF::_pITypeLibIxsso->Release();
CIxssoQueryCF::_pITypeLibIxsso = 0;
}
if (g_pTheGlobalIXSSOVariables)
{
delete g_pTheGlobalIXSSOVariables;
g_pTheGlobalIXSSOVariables = 0;
}
DeleteCriticalSection( &g_cs );
// DbgPrint("IXSSO: [DLL] Process Detached\n");
break;
}
}
CATCH( CException, e )
{
// About the only thing this could be is STATUS_NO_MEMORY which
// can be thrown by InitializeCriticalSection.
ixssoDebugOut(( DEB_ERROR,
"IXSSO: Exception %#x in DllMain\n",
e.GetErrorCode()));
#if CIDBG == 1 // for debugging NTRAID 340297
if (e.GetErrorCode() == STATUS_NO_MEMORY)
DbgPrint( "IXSSO: STATUS_NO_MEMORY exception in DllMain\n");
else
DbgPrint( "IXSSO: ??? Exception in DllMain\n");
#endif // CIDBG == 1
fRetval = FALSE;
}
END_CATCH
UNTRANSLATE_EXCEPTIONS;
return fRetval;
}