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.
 
 
 
 
 
 

624 lines
14 KiB

//***************************************************************************
//
// File:
//
// Module: MS SNMP Provider
//
// Purpose:
//
// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
//
//***************************************************************************
#include "precomp.h"
#include <provexpt.h>
#include <objbase.h>
#include <olectl.h>
#include <corafx.h>
#include <wbemidl.h>
#include "guids.h"
#include <snmpstd.h>
#include <snmpmt.h>
#include <snmptempl.h>
#include <snmpcont.h>
#include <snmpevt.h>
#include <snmpthrd.h>
#include <snmplog.h>
#include <instpath.h>
#include <snmpcl.h>
#include <snmptype.h>
#include <snmpobj.h>
#include <smir.h>
#include "classfac.h"
#include "clasprov.h"
#include "propprov.h"
#include <corstore.h>
#include <corrsnmp.h>
#include <correlat.h>
#include <notify.h>
#include <cormap.h>
#include <evtdefs.h>
#include <evtthrd.h>
#include <evtmap.h>
#include <evtprov.h>
ISmirDatabase* g_pNotifyInt = NULL;
CCorrCacheNotify* gp_notify = NULL;
CCorrCacheWrapper* g_CacheWrapper = NULL;
CCorrelatorMap* g_Map = NULL;
//OK we need this one
HINSTANCE g_hInst=NULL;
CEventProviderThread* g_pProvThrd = NULL;
CEventProviderWorkerThread* g_pWorkerThread = NULL;
CRITICAL_SECTION s_ProviderCriticalSection ;
CRITICAL_SECTION g_CacheCriticalSection ;
extern void ProviderStartup () ;
extern void ProviderClosedown () ;
//***************************************************************************
//
// LibMain32
//
// Purpose: Entry point for DLL. Good place for initialization.
// Return: TRUE if OK.
//***************************************************************************
BOOL APIENTRY DllMain (
HINSTANCE hInstance,
ULONG ulReason ,
LPVOID pvReserved
)
{
SetStructuredExceptionHandler seh;
try
{
g_hInst=hInstance;
BOOL status = TRUE ;
if ( DLL_PROCESS_DETACH == ulReason )
{
DeleteCriticalSection ( & s_ProviderCriticalSection ) ;
DeleteCriticalSection ( & g_CacheCriticalSection ) ;
status = TRUE ;
}
else if ( DLL_PROCESS_ATTACH == ulReason )
{
DisableThreadLibraryCalls(hInstance);
InitializeCriticalSection ( & s_ProviderCriticalSection ) ;
InitializeCriticalSection ( & g_CacheCriticalSection ) ;
status = TRUE ;
}
else if ( DLL_THREAD_DETACH == ulReason )
{
status = TRUE ;
}
else if ( DLL_THREAD_ATTACH == ulReason )
{
status = TRUE ;
}
return TRUE ;
}
catch(Structured_Exception e_SE)
{
return FALSE;
}
catch(Heap_Exception e_HE)
{
return FALSE;
}
catch(...)
{
return FALSE;
}
}
//***************************************************************************
//
// DllGetClassObject
//
// Purpose: Called by Ole when some client wants a a class factory. Return
// one only if it is the sort of class this DLL supports.
//
//***************************************************************************
STDAPI DllGetClassObject (
REFCLSID rclsid ,
REFIID riid,
void **ppv
)
{
SetStructuredExceptionHandler seh;
try
{
HRESULT status = S_OK ;
if ( rclsid == CLSID_CClasProvClassFactory )
{
CClasProvClassFactory *lpunk = new CClasProvClassFactory ;
if ( lpunk == NULL )
{
status = E_OUTOFMEMORY ;
}
else
{
status = lpunk->QueryInterface ( riid , ppv ) ;
if ( FAILED ( status ) )
{
delete lpunk ;
}
else
{
}
}
}
else if ( rclsid == CLSID_CPropProvClassFactory )
{
CPropProvClassFactory *lpunk = new CPropProvClassFactory ;
if ( lpunk == NULL )
{
status = E_OUTOFMEMORY ;
}
else
{
status = lpunk->QueryInterface ( riid , ppv ) ;
if ( FAILED ( status ) )
{
delete lpunk ;
}
else
{
}
}
}
else if ( rclsid == CLSID_CSNMPReftEventProviderClassFactory )
{
CSNMPRefEventProviderClassFactory *lpunk = new CSNMPRefEventProviderClassFactory;
if ( lpunk == NULL )
{
status = E_OUTOFMEMORY ;
}
else
{
status = lpunk->QueryInterface ( riid , ppv ) ;
if ( FAILED ( status ) )
{
delete lpunk ;
}
}
}
else if ( rclsid == CLSID_CSNMPEncapEventProviderClassFactory )
{
CSNMPEncapEventProviderClassFactory *lpunk = new CSNMPEncapEventProviderClassFactory;
if ( lpunk == NULL )
{
status = E_OUTOFMEMORY ;
}
else
{
status = lpunk->QueryInterface ( riid , ppv ) ;
if ( FAILED ( status ) )
{
delete lpunk ;
}
}
}
else
{
status = CLASS_E_CLASSNOTAVAILABLE ;
}
return status ;
}
catch(Structured_Exception e_SE)
{
return E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
return E_OUTOFMEMORY;
}
catch(...)
{
return E_UNEXPECTED;
}
}
//***************************************************************************
//
// DllCanUnloadNow
//
// Purpose: Called periodically by Ole in order to determine if the
// DLL can be freed.//
// Return: TRUE if there are no objects in use and the class factory
// isn't locked.
//***************************************************************************
STDAPI DllCanUnloadNow ()
{
SetStructuredExceptionHandler seh;
try
{
/*
* Place code in critical section
*/
EnterCriticalSection ( & s_ProviderCriticalSection ) ;
ISmirDatabase* t_pNotifyInt = NULL;
CCorrCacheNotify* t_pnotify = NULL;
CEventCacheNotify* t_notify = NULL;
ISmirDatabase* t_pNotifyIntThread = NULL;
BOOL unload = (
CClasProvClassFactory :: locksInProgress ||
CClasProvClassFactory :: objectsInProgress ||
CPropProvClassFactory :: locksInProgress ||
CPropProvClassFactory :: objectsInProgress ||
CSNMPEventProviderClassFactory :: locksInProgress ||
CSNMPEventProviderClassFactory :: objectsInProgress
) ;
unload = ! unload ;
if ( unload )
{
if ( CImpClasProv :: s_Initialised )
{
CImpClasProv :: s_Initialised = FALSE ;
CCorrelator :: TerminateCorrelator (&t_pNotifyInt, &t_pnotify) ;
SnmpClassLibrary :: Closedown () ;
SnmpDebugLog :: Closedown () ;
SnmpThreadObject :: Closedown () ;
ProviderClosedown () ;
}
if ( CImpPropProv :: s_Initialised )
{
CImpPropProv :: s_Initialised = FALSE ;
SnmpClassLibrary :: Closedown () ;
SnmpDebugLog :: Closedown () ;
SnmpThreadObject :: Closedown () ;
ProviderClosedown () ;
}
if ( g_pProvThrd )
{
delete g_pProvThrd;
g_pProvThrd = NULL;
g_pWorkerThread->GetDeleteNotifyParams(&t_pNotifyIntThread, &t_notify);
g_pWorkerThread->SignalThreadShutdown();
g_pWorkerThread = NULL;
SnmpClassLibrary :: Closedown () ;
SnmpDebugLog :: Closedown () ;
SnmpThreadObject :: Closedown () ;
ProviderClosedown () ;
}
}
LeaveCriticalSection ( & s_ProviderCriticalSection ) ;
if (unload)
{
if (t_pNotifyInt)
{
if (t_pnotify)
{
t_pNotifyInt->DeleteNotify(t_pnotify->GetCookie());
}
t_pNotifyInt->Release();
t_pNotifyInt = NULL;
}
if (t_pnotify)
{
t_pnotify->Release();
t_pnotify = NULL;
}
if (t_pNotifyIntThread)
{
if (t_notify)
{
t_pNotifyIntThread->DeleteNotify(t_notify->GetCookie());
}
t_pNotifyIntThread->Release();
t_pNotifyIntThread = NULL;
}
if (t_notify)
{
t_notify->Release();
t_notify = NULL;
}
}
return unload ? ResultFromScode ( S_OK ) : ResultFromScode ( S_FALSE ) ;
}
catch(Structured_Exception e_SE)
{
return S_FALSE;
}
catch(Heap_Exception e_HE)
{
return S_FALSE;
}
catch(...)
{
return S_FALSE;
}
}
#define REG_FORMAT_STR L"%s\\%s"
#define NOT_INSERT_STR L"NotInsertable"
#define INPROC32_STR L"InprocServer32"
#define LOCALSERVER32_STR L"LocalServer32"
#define THREADING_MODULE_STR L"ThreadingModel"
#define APARTMENT_STR L"Both"
#define APPID_STR L"Software\\Classes\\AppID\\"
#define CLSID_STR L"Software\\Classes\\CLSID\\"
#define CLASS_PROVIDER_NAME_STR L"Microsoft WBEM SNMP Class Provider"
#define INSTANCE_PROVIDER_NAME_STR L"Microsoft WBEM SNMP Instance Provider"
#define EVENT_PROVIDER_NAME_STR L"Microsoft WBEM SNMP Event Provider"
/***************************************************************************
* SetKeyAndValue
*
* Purpose:
* Private helper function for DllRegisterServer that creates
* a key, sets a value, and closes that key.
*
* Parameters:
* pszKey LPTSTR to the ame of the key
* pszSubkey LPTSTR ro the name of a subkey
* pszValue LPTSTR to the value to store
*
* Return Value:
* BOOL TRUE if successful, FALSE otherwise.
***************************************************************************/
BOOL SetKeyAndValue(wchar_t* pszKey, wchar_t* pszSubkey, wchar_t* pszValueName, wchar_t* pszValue)
{
HKEY hKey;
wchar_t szKey[256];
wcscpy(szKey, pszKey);
if (NULL!=pszSubkey)
{
wcscat(szKey, L"\\");
wcscat(szKey, pszSubkey);
}
if (ERROR_SUCCESS!=RegCreateKeyEx(HKEY_LOCAL_MACHINE
, szKey, 0, NULL, REG_OPTION_NON_VOLATILE
, KEY_ALL_ACCESS, NULL, &hKey, NULL))
return FALSE;
if (NULL!=pszValue)
{
if (ERROR_SUCCESS != RegSetValueEx(hKey, pszValueName, 0, REG_SZ, (BYTE *)pszValue
, (lstrlen(pszValue)+1)*sizeof(wchar_t)))
return FALSE;
}
RegCloseKey(hKey);
return TRUE;
}
/***************************************************************************
* DllRegisterServer
*
* Purpose:
* Instructs the server to create its own registry entries
*
* Parameters:
* None
*
* Return Value:
* HRESULT NOERROR if registration successful, error
* otherwise.
***************************************************************************/
STDAPI RegisterServer( GUID a_ProviderClassId , wchar_t *a_ProviderName )
{
wchar_t szModule[512];
GetModuleFileName(g_hInst,(wchar_t*)szModule, sizeof(szModule)/sizeof(wchar_t));
wchar_t szProviderClassID[128];
wchar_t szProviderCLSIDClassID[128];
int iRet = StringFromGUID2(a_ProviderClassId,szProviderClassID, 128);
#ifdef LOCALSERVER
TCHAR szProviderCLSIDAppID[128];
_tcscpy(szProviderCLSIDAppID,APPID_STR);
_tcscat(szProviderCLSIDAppID,szProviderClassID);
if (FALSE ==SetKeyAndValue(szProviderCLSIDAppID, NULL, NULL, a_ProviderName ))
return SELFREG_E_CLASS;
#endif
wcscpy(szProviderCLSIDClassID,CLSID_STR);
wcscat(szProviderCLSIDClassID,szProviderClassID);
//Create entries under CLSID
if (FALSE ==SetKeyAndValue(szProviderCLSIDClassID, NULL, NULL, a_ProviderName ))
return SELFREG_E_CLASS;
if (FALSE ==SetKeyAndValue(szProviderCLSIDClassID, NOT_INSERT_STR, NULL, NULL))
return SELFREG_E_CLASS;
#ifdef LOCALSERVER
if (FALSE ==SetKeyAndValue(szProviderCLSIDClassID, LOCALSERVER32_STR, NULL,szModule))
return SELFREG_E_CLASS;
if (FALSE ==SetKeyAndValue(szProviderCLSIDClassID, LOCALSERVER32_STR,THREADING_MODULE_STR, APARTMENT_STR))
return SELFREG_E_CLASS;
#else
if (FALSE ==SetKeyAndValue(szProviderCLSIDClassID, INPROC32_STR, NULL,szModule))
return SELFREG_E_CLASS;
if (FALSE ==SetKeyAndValue(szProviderCLSIDClassID, INPROC32_STR,THREADING_MODULE_STR, APARTMENT_STR))
return SELFREG_E_CLASS;
#endif
return S_OK;
}
/***************************************************************************
* DllUnregisterServer
*
* Purpose:
* Instructs the server to remove its own registry entries
*
* Parameters:
* None
*
* Return Value:
* HRESULT NOERROR if registration successful, error
* otherwise.
***************************************************************************/
STDAPI UnregisterServer( GUID a_ProviderClassId )
{
wchar_t szTemp[128];
wchar_t szProviderClassID[128];
wchar_t szProviderCLSIDClassID[128];
int iRet = StringFromGUID2(a_ProviderClassId ,szProviderClassID, 128);
wcscpy(szProviderCLSIDClassID,CLSID_STR);
wcscat(szProviderCLSIDClassID,szProviderClassID);
//Delete entries under CLSID
wsprintf(szTemp, REG_FORMAT_STR, szProviderCLSIDClassID, NOT_INSERT_STR);
RegDeleteKey(HKEY_LOCAL_MACHINE, szTemp);
#ifdef LOCALSERVER
TCHAR szProviderCLSIDAppID[128];
_tcscpy(szProviderCLSIDAppID,APPID_STR);
_tcscat(szProviderCLSIDAppID,szProviderClassID);
//Delete entries under APPID
DWORD t_Status = RegDeleteKey(HKEY_CLASSES_ROOT, szProviderCLSIDAppID);
wsprintf(szTemp, REG_FORMAT_STR,szProviderCLSIDClassID, LOCALSERVER32_STR);
t_Status = RegDeleteKey(HKEY_CLASSES_ROOT, szTemp);
#else
wsprintf(szTemp, REG_FORMAT_STR,szProviderCLSIDClassID, INPROC32_STR);
RegDeleteKey(HKEY_LOCAL_MACHINE, szTemp);
#endif
RegDeleteKey(HKEY_LOCAL_MACHINE, szProviderCLSIDClassID);
return S_OK;
}
STDAPI DllRegisterServer()
{
SetStructuredExceptionHandler seh;
try
{
HRESULT t_Result ;
t_Result = RegisterServer ( CLSID_CPropProvClassFactory , INSTANCE_PROVIDER_NAME_STR ) ;
t_Result = FAILED ( t_Result ) ? t_Result : RegisterServer ( CLSID_CClasProvClassFactory , CLASS_PROVIDER_NAME_STR ) ;
t_Result = FAILED ( t_Result ) ? t_Result : RegisterServer ( CLSID_CSNMPReftEventProviderClassFactory , EVENT_PROVIDER_NAME_STR ) ;
t_Result = FAILED ( t_Result ) ? t_Result : RegisterServer ( CLSID_CSNMPEncapEventProviderClassFactory , EVENT_PROVIDER_NAME_STR ) ;
return t_Result ;
}
catch(Structured_Exception e_SE)
{
return E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
return E_OUTOFMEMORY;
}
catch(...)
{
return E_UNEXPECTED;
}
}
STDAPI DllUnregisterServer(void)
{
SetStructuredExceptionHandler seh;
try
{
HRESULT t_Result ;
t_Result = UnregisterServer ( CLSID_CPropProvClassFactory ) ;
t_Result = FAILED ( t_Result ) ? t_Result : UnregisterServer ( CLSID_CClasProvClassFactory ) ;
t_Result = FAILED ( t_Result ) ? t_Result : UnregisterServer ( CLSID_CSNMPReftEventProviderClassFactory ) ;
t_Result = FAILED ( t_Result ) ? t_Result : UnregisterServer ( CLSID_CSNMPEncapEventProviderClassFactory ) ;
return t_Result ;
}
catch(Structured_Exception e_SE)
{
return E_UNEXPECTED;
}
catch(Heap_Exception e_HE)
{
return E_OUTOFMEMORY;
}
catch(...)
{
return E_UNEXPECTED;
}
}