//***************************************************************************

//

//  File:	

//

//  Module: MS SNMP Provider

//

//  Purpose: 

//

// Copyright (c) 1997-2001 Microsoft Corporation, All Rights Reserved
//
//***************************************************************************

#include <precomp.h>
#include "csmir.h"
#include "smir.h"
#include <helper.h>
#include "handles.h"
#include "classfac.h"
#include <textdef.h>
#include "bstring.h"
#include "evtcons.h"
#ifdef ICECAP_PROFILE
#include <icapexp.h>
#endif
#include <cominit.h>

extern BOOL g_initialised ;

//BSTR Helpers
SCODE CopyBSTR(BSTR *pDst, BSTR *pSrc)
{
	if(*pDst)
		SysFreeString(*pDst);
	if(*pSrc)
	{
		*pDst = SysAllocString(*pSrc);
		return S_OK;
	}
	else
		return E_INVALIDARG;
}
// {74864DA1-0630-11d0-A5B6-00AA00680C3F}
//DEFINE_GUID(CLSID_MosGateway, 
//0x74864da1, 0x630, 0x11d0, 0xa5, 0xb6, 0x0, 0xaa, 0x0, 0x68, 0xc, 0x3f);

BOOL SetKeyAndValue(wchar_t* pszKey, wchar_t* pszSubkey,  wchar_t* pszValueName, wchar_t* pszValue);

SmirClassFactoryHelper :: SmirClassFactoryHelper()
:	pGroupHandleClassFactory(NULL), pClassHandleClassFactory(NULL),
	pModHandleClassFactory(NULL), pSMIRClassFactory(NULL),
	pNotificationClassHandleClassFactory(NULL), pExtNotificationClassHandleClassFactory(NULL)
{
}

SmirClassFactoryHelper :: ~SmirClassFactoryHelper()
{
	if(NULL != pGroupHandleClassFactory)
		pGroupHandleClassFactory->Release();
	if(NULL != pClassHandleClassFactory)
		pClassHandleClassFactory->Release();
	if(NULL != pModHandleClassFactory)
		pModHandleClassFactory->Release();
	if(NULL != pNotificationClassHandleClassFactory)
		pNotificationClassHandleClassFactory->Release();
	if(NULL != pExtNotificationClassHandleClassFactory)
		pExtNotificationClassHandleClassFactory->Release();
	if(NULL != pSMIRClassFactory )
	{
		pSMIRClassFactory->Release();
	}
}

SCODE SmirClassFactoryHelper :: CreateInstance(REFCLSID rclsid,REFIID riid, LPVOID * ppv)
{
	CSMIRGenericClassFactory *ppClassFactory = NULL ;
	SCODE result = S_OK;
	*ppv=NULL;
	
	if((CLSID_SMIR_Database==rclsid)||
				(IID_IConnectionPointContainer==rclsid))
	{
		ppClassFactory = new CSMIRClassFactory(rclsid);
	}
	else if(CLSID_SMIR_ModHandle == rclsid)
	{
		ppClassFactory = new CModHandleClassFactory(rclsid);
	}
	else if(CLSID_SMIR_GroupHandle == rclsid)
	{
		ppClassFactory = new CGroupHandleClassFactory(rclsid);
	}
	else if(CLSID_SMIR_ClassHandle == rclsid)
	{
		ppClassFactory = new CClassHandleClassFactory(rclsid);
	}
	else if(CLSID_SMIR_NotificationClassHandle == rclsid)
	{
		ppClassFactory = new CNotificationClassHandleClassFactory(rclsid);
	}
	else if(CLSID_SMIR_ExtNotificationClassHandle == rclsid)
	{
		ppClassFactory = new CExtNotificationClassHandleClassFactory(rclsid);
	}

	ppClassFactory->AddRef();
	result = ppClassFactory->CreateInstance (NULL ,riid ,ppv);
	ppClassFactory->Release();

	if((S_OK != result)||(*ppv == NULL))
	{
		return result;
	}
	return result;
}

/* CSmirAccess
 *A simple class to open and create the smir - extended to opan any namespace
 */

void CSmirAccess :: ShutDown ()
{
	if (CSmir::sm_ConnectionObjects != NULL)
	{
		CSmir::sm_ConnectionObjects->Release ();
		CSmir::sm_ConnectionObjects = NULL ;
	}

	if(NULL != g_pClassFactoryHelper)
	{
		delete g_pClassFactoryHelper;
		g_pClassFactoryHelper = NULL;
	}
	
	//SMIR requires re-initialization!
	g_initialised = FALSE ;
}

STDMETHODIMP CSmirAccess :: Init ()
{
	return S_OK;
}

STDMETHODIMP CSmirAccess :: Open (

	CSmir *a_Smir , 
	IWbemServices **server, 
	BSTR ObjectPath, 
	BOOL relativeToSMIR
)
{
	IWbemServices *returnedServ = NULL ;
	*server=NULL;

	if (relativeToSMIR && (ObjectPath == NULL))
	{
		return WBEM_E_FAILED;
	}

	if(FAILED(Connect(a_Smir, &returnedServ, ObjectPath, relativeToSMIR)))
	{
		return WBEM_E_FAILED;
	}
	*server = returnedServ;
	return S_OK;
}

STDMETHODIMP CSmirAccess :: Open(

	CSmir *a_Smir , 
	IWbemServices **server, 
	ISmirClassHandle *hClass, 
	eOpenType eType
)
{
	if(NULL == server)
		return WBEM_E_FAILED;

	SCODE returnCode=S_OK;

	BSTR szTModstr = NULL;
	BSTR szTGroupstr = NULL;
	hClass->GetModuleName(&szTModstr);
	hClass->GetGroupName(&szTGroupstr);

	wchar_t *pTGroupNSString = NULL ;
	if(eType == eGroup)
	{
		hClass->GetGroupName(&szTGroupstr);
		pTGroupNSString = new wchar_t[wcslen(SMIR_NAMESPACE)+wcslen(BACKSLASH_STR)
				+wcslen(szTModstr)+wcslen(BACKSLASH_STR)+wcslen(szTGroupstr)+1];
	}
	else
	{
		hClass->GetGroupName(&szTGroupstr);
		pTGroupNSString = new wchar_t[wcslen(SMIR_NAMESPACE)+wcslen(BACKSLASH_STR)
				+wcslen(szTModstr)+1];
	}

	if(NULL != pTGroupNSString)
	{
		wcscpy(pTGroupNSString,szTModstr);
		//<module name>
		if(eType == eGroup)
		{	
			wcscat(pTGroupNSString,BACKSLASH_STR);
			wcscat(pTGroupNSString,szTGroupstr);
			// <module name>\<group name>
		}

		CBString t_Str ( pTGroupNSString ) ;
		SCODE result= CSmirAccess :: Open(

			a_Smir, 
			server, 
			t_Str.GetString (), 
			TRUE
		);

		delete [] pTGroupNSString;
		
		if ((FAILED(result))||(NULL == server))
		{
			//if we can't open the namespace the group handle must be invalid
			returnCode =  result;
		}
	}
	else
	{
		returnCode= E_OUTOFMEMORY;
	}

	if(FAILED(returnCode))
	{
		FormatProviderErrorMsg(__FILE__,__LINE__,returnCode);
		returnCode = (returnCode==E_OUTOFMEMORY?E_OUTOFMEMORY:WBEM_E_FAILED);
	}

	//free the string we got from hGroup
	SysFreeString(szTModstr);
	SysFreeString(szTGroupstr);

	return returnCode;
}

STDMETHODIMP CSmirAccess :: Open(

	CSmir *a_Smir , 
	IWbemServices **server, 
	ISmirGroupHandle *hGroup, 
	eOpenType eType
)
{
	if(NULL == server)
		return WBEM_E_FAILED;

	SCODE returnCode=S_OK;

	BSTR szTModstr=NULL;
	BSTR szTGroupstr=NULL;
	hGroup->GetModuleName(&szTModstr);

	wchar_t *pTGroupNSString = NULL;
	if(eType == eGroup)
	{
		hGroup->GetName(&szTGroupstr);
		pTGroupNSString =new wchar_t[wcslen(SMIR_NAMESPACE)+wcslen(BACKSLASH_STR)
				+wcslen(szTModstr)+wcslen(BACKSLASH_STR)+wcslen(szTGroupstr)+1];
	}
	else
	{
		pTGroupNSString =new wchar_t[wcslen(SMIR_NAMESPACE)+wcslen(BACKSLASH_STR)
				+wcslen(szTModstr)+1];
	}

	if(NULL != pTGroupNSString)
	{
		wcscpy(pTGroupNSString,szTModstr);
		// <module name>
		if(eType == eGroup)
		{
			wcscat(pTGroupNSString,BACKSLASH_STR);
			wcscat(pTGroupNSString,szTGroupstr);
		}
		// <module name>\<group name>

		CBString t_BStr ( pTGroupNSString ) ;

		SCODE result= CSmirAccess :: Open (

			a_Smir, 
			server, 
			t_BStr.GetString (), 
			TRUE
		);

		delete [] pTGroupNSString;
		
		if ((FAILED(result))||(NULL == server))
		{
			//if we can't open the namespace the group handle must be invalid
			returnCode = result;
		}
	}
	else
	{
		returnCode = E_OUTOFMEMORY;
	}

	if(FAILED(returnCode))
	{
		FormatProviderErrorMsg(__FILE__,__LINE__,returnCode);
		returnCode = (returnCode==E_OUTOFMEMORY?E_OUTOFMEMORY:WBEM_E_FAILED);
	}

	//free the strings we got from hModule and hGroup
	SysFreeString(szTModstr);
	SysFreeString(szTGroupstr);

	return returnCode;
}

STDMETHODIMP CSmirAccess :: Open (

	CSmir *a_Smir , 
	IWbemServices **server, 
	ISmirModHandle *hMod
)
{
	if(NULL == server)
		return WBEM_E_FAILED;
	
	SCODE returnCode=S_OK;

	//open the module name space
	//build the object path
	BSTR szTstr=NULL;
	hMod->GetName(&szTstr);
	wchar_t *pTstring = new wchar_t[wcslen(SMIR_NAMESPACE)+wcslen(BACKSLASH_STR)+wcslen(szTstr)+1];

	if(NULL != pTstring)
	{
		wcscpy(pTstring,szTstr);
		// <module name>

		CBString t_BStr ( pTstring ) ;
		SCODE res = CSmirAccess :: Open (

			a_Smir, 
			server,
			t_BStr.GetString (), 
			TRUE
		);

		//clean up
		delete [] pTstring;
		
		if (FAILED(res)||(NULL == server))
		{
			returnCode = res;
		}
	}
	else
	{
		returnCode =  E_OUTOFMEMORY;
	}

	//free the string we got from hGroup
	SysFreeString(szTstr);

	if(FAILED(returnCode))
	{
		returnCode = (returnCode==E_OUTOFMEMORY?E_OUTOFMEMORY:WBEM_E_FAILED);
	}

	return S_OK;
}

STDMETHODIMP CSmirAccess :: Connect (

	IN CSmir *a_Smir , 
	OUT IWbemServices **a_Server, 
	IN BSTR a_Namespace , 
	IN BOOL a_RelativeToSMIR
)
{
	//I only have one point of failure so don't use the garbage collector
	*a_Server = NULL;

	//open the  namespace (default is the smir)

	HRESULT t_Result;

	ISMIRWbemConfiguration *t_Configuration = NULL ;
	IWbemServices *t_Service = NULL ;
	IWbemContext *t_Context = NULL;

	t_Result = a_Smir->QueryInterface (

		IID_ISMIRWbemConfiguration ,
		( void **) & t_Configuration
	) ;

	if ( SUCCEEDED ( t_Result ) )
	{
		t_Configuration->GetContext ( & t_Context ) ;
		t_Result = t_Configuration->GetServices ( & t_Service ) ;

		if ( SUCCEEDED ( t_Result ) )
		{
			t_Result = WbemSetProxyBlanket(t_Service,
				RPC_C_AUTHN_DEFAULT,
				RPC_C_AUTHZ_DEFAULT,
				COLE_DEFAULT_PRINCIPAL,
				RPC_C_AUTHN_LEVEL_DEFAULT,
				RPC_C_IMP_LEVEL_DEFAULT,
				NULL,
				EOAC_DYNAMIC_CLOAKING);

			if ( FAILED ( t_Result ) && t_Result != E_NOINTERFACE )
			{
				t_Service->Release();
				t_Service = NULL;
			}
			else
			{
				t_Result = S_OK ;
			}
		}
		else
		{
			t_Result = t_Configuration->Authenticate (

				NULL,
				NULL,
				NULL,
				NULL,
				0 ,
				NULL ,
				TRUE
			) ;

			if ( SUCCEEDED ( t_Result ) )
			{
				t_Result = t_Configuration->GetServices ( & t_Service ) ;
				
				if ( SUCCEEDED ( t_Result ) )
				{
					t_Result = WbemSetProxyBlanket(t_Service,
						RPC_C_AUTHN_DEFAULT,
						RPC_C_AUTHZ_DEFAULT,
						COLE_DEFAULT_PRINCIPAL,
						RPC_C_AUTHN_LEVEL_DEFAULT,
						RPC_C_IMP_LEVEL_DEFAULT,
						NULL,
						EOAC_DYNAMIC_CLOAKING);

					if ( FAILED ( t_Result ) && t_Result != E_NOINTERFACE )
					{
						t_Service->Release();
						t_Service = NULL;
					}
					else
					{
						t_Result = S_OK ;
					}
				}
			}
		}

		t_Configuration->Release () ;
	}

	if ( SUCCEEDED ( t_Result ) )
	{
		if( a_Namespace != NULL )
		{
			CBString t_BStr ( a_Namespace )  ;

			if ( a_RelativeToSMIR )
			{
				t_Result = t_Service->OpenNamespace (

					t_BStr.GetString (), 
					0,
					t_Context, 
					a_Server, 
					NULL
				);

				if ( SUCCEEDED ( t_Result ) )
				{
					t_Result = WbemSetProxyBlanket(*a_Server,
						RPC_C_AUTHN_DEFAULT,
						RPC_C_AUTHZ_DEFAULT,
						COLE_DEFAULT_PRINCIPAL,
						RPC_C_AUTHN_LEVEL_DEFAULT,
						RPC_C_IMP_LEVEL_DEFAULT,
						NULL,
						EOAC_DYNAMIC_CLOAKING);

					if ( FAILED ( t_Result )  && t_Result != E_NOINTERFACE )
					{
						(*a_Server)->Release();
						(*a_Server) = NULL;
					}
					else
					{
						t_Result = S_OK ;
					}
				}
			}
			else
			{
				t_Result = WBEM_E_FAILED ;
			}

			t_Service->Release () ;
		}
		else
		{
			*a_Server = t_Service ;
		}
	}

	if ( t_Context )
		t_Context->Release();
 
	return t_Result ;
}

STDMETHODIMP CSmirAccess :: GetContext (

	IN CSmir *a_Smir , 
	OUT IWbemContext **a_Context
)
{
	//I only have one point of failure so don't use the garbage collector
	*a_Context = NULL;

	//open the  namespace (default is the smir)

	HRESULT t_Result;

	ISMIRWbemConfiguration *t_Configuration = NULL ;

	t_Result = a_Smir->QueryInterface (

		IID_ISMIRWbemConfiguration ,
		( void **) & t_Configuration
	) ;

	if ( SUCCEEDED ( t_Result ) )
	{
		t_Result = t_Configuration->GetContext ( a_Context ) ;
		t_Configuration->Release () ;
	}

	return t_Result ;
}

void FormatProviderErrorMsg(char*file, int line, SCODE errorCode)
{
	//use the strings
	switch (errorCode)
	{
		case WBEM_NO_ERROR:
		break;
		case WBEM_S_NO_MORE_DATA:
		break;
		case WBEM_E_FAILED:
		break;
		case WBEM_E_NOT_FOUND:
		break;
		case WBEM_E_ACCESS_DENIED:
		break;
		case WBEM_E_PROVIDER_FAILURE:
		break;
		case WBEM_E_TYPE_MISMATCH:
		break;
		case WBEM_E_OUT_OF_MEMORY:
		break;
		case WBEM_E_INVALID_CONTEXT:
		break;
		case WBEM_E_INVALID_PARAMETER:
		break;
		case WBEM_E_NOT_AVAILABLE:
		break;
		case WBEM_E_CRITICAL_ERROR:
		break;
		case WBEM_E_INVALID_STREAM:
		break;
		case WBEM_E_NOT_SUPPORTED:
		break;
		case WBEM_E_INVALID_SUPERCLASS:
		break;
		case WBEM_E_INVALID_NAMESPACE:
		break;
		case WBEM_E_INVALID_OBJECT:
		break;
		case WBEM_E_INVALID_CLASS:
		break;
		case WBEM_E_PROVIDER_NOT_FOUND:
		break;
		case WBEM_E_INVALID_PROVIDER_REGISTRATION:
		break;
		case WBEM_E_PROVIDER_LOAD_FAILURE:
		break;
		case WBEM_E_INITIALIZATION_FAILURE:
		break;
		case WBEM_E_INVALID_OPERATION:
		break;
		case WBEM_E_INVALID_QUERY:
		break;
		case WBEM_E_INVALID_QUERY_TYPE:
		break;
		case E_INVALIDARG:
		break;
		case E_UNEXPECTED:
		break;
		case E_OUTOFMEMORY:
		break;
		default:
		break;
	}
}

SCODE CGroupToClassAssociator :: Associate (

	CSmir *a_Smir,
	BSTR szModuleName, 
	BSTR szGroupName, 
	ISmirClassHandle *hClass
)
{
	if ((NULL == hClass)||(NULL==szModuleName)||(NULL==szGroupName))
		return WBEM_E_FAILED;

	IWbemServices *moServ = NULL ;
	IWbemContext *moContext = NULL ;
	SCODE result= CSmirAccess :: GetContext (a_Smir , &moContext);
	//open the root\default\SMIR namespace
	CSmirAccess :: Open(a_Smir,&moServ);

	IWbemClassObject *pClass = NULL ;
	CBString t_BStr ( SMIR_GROUP_ASSOC_CLASS_NAME ) ;
	result = moServ->GetObject(t_BStr.GetString (), 0, 
									moContext,&pClass, NULL);

	if ((FAILED(result))||(NULL == pClass))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	IWbemClassObject *pInst = NULL ;
	result = pClass->SpawnInstance ( 0 , &pInst ) ;
	pClass->Release ();

	if ((FAILED(result))||(NULL==pInst))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	VARIANT v;
	VariantInit(&v);

	//Get the class name
	result  = ((CSmirClassHandle*)hClass)->m_pIMosClass->Get(OLEMS_CLASS_PROP, 
													RESERVED_WBEM_FLAG,  &v,NULL,NULL);
	if ((FAILED(result))|(V_VT(&v) != VT_BSTR))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}
	BSTR szClassName = SysAllocString(V_BSTR(&v));
	VariantClear(&v);

	/****************give it a Name property**********************************/
	CString associationClassName(CString(szClassName)
						+CString(SMIR_GROUP_ASSOC_CLASS_NAME_POSTFIX));

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=associationClassName.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_NAME_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);

	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		SysFreeString(szClassName);
		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}
	/****************give it a class property**********************************/
	//get the fully qualified class name
	//classes = "\\\\.\\root\\default\\SMIR:MS_SNMP_RFC1213_MIB_atTable";
	CString classPath(CString(SMIR_NAMESPACE_FROM_ROOT)
						+CString(COLON_STR)
						+CString(szClassName));

	//don't need this anymore
	SysFreeString(szClassName);

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=classPath.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_CLASS_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}

	/****************give it a group property**********************************/
	//get the fully qualified class name
	//group = "\\\\.\\root\\default\\SMIR\\RFC1213_MIB:Group=\"atV1ObjectGroup\"";
	CString groupPath(CString(SMIR_NAMESPACE_FROM_ROOT)
				+CString(BACKSLASH_STR)
				+CString(szModuleName)
				+CString(COLON_STR)
				+CString(GROUP_NAMESPACE_NAME)
				+CString(DOT_STR)
				+CString(OLEMS_NAME_PROP)
				+CString(EQUALS_STR)
				+CString(QUOTE_STR)
				+CString(szGroupName)
				+CString(QUOTE_STR));

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=groupPath.AllocSysString();
	result = pInst->Put(SMIR_GROUP_ASSOC_GROUP_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}

	//now save it
	result = moServ->PutInstance(pInst, RESERVED_WBEM_FLAG, moContext,NULL);

	if ( moContext )
		moContext->Release () ;

	pInst->Release();
	moServ->Release();
	
	/*the query to find the classes is
	 *associators of {\\.\root\default\SMIR\RFC1316-MIB:Group="charV1ObjectGroup"}
	 *or
	 *associators of {\\.\root\default\SMIR\RFC1213-MIB:Group="atV1ObjectGroup"}
		 */
	return S_OK;
}

SCODE CModuleToClassAssociator :: Associate (

	CSmir *a_Smir,
	BSTR szModuleName, 
	ISmirClassHandle *hClass
)
{
	if ((NULL == hClass)||(NULL==szModuleName))
		return WBEM_E_FAILED;

	IWbemServices *	moServ = NULL ;
	IWbemContext *moContext = NULL ;
	SCODE result= CSmirAccess :: GetContext (a_Smir , &moContext);

	//open the root\default\SMIR namespace
	CSmirAccess :: Open(a_Smir,&moServ);

	//get an object
	IWbemClassObject *pClass = NULL ;
	CBString t_BStr ( SMIR_MODULE_ASSOC_CLASS_NAME ) ;
	result = moServ->GetObject(t_BStr.GetString (), 0, 
									moContext,&pClass, NULL);

	if ((FAILED(result))||(NULL == pClass))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	IWbemClassObject *pInst = NULL ;
	result = pClass->SpawnInstance ( 0 , &pInst ) ;
	pClass->Release ();

	if ((FAILED(result))||(NULL==pInst))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	VARIANT v;
	VariantInit(&v);

	//Get the class name
	result  = ((CSmirClassHandle*)hClass)->m_pIMosClass->Get(OLEMS_CLASS_PROP, 
												RESERVED_WBEM_FLAG,  &v,NULL,NULL);

	if ((FAILED(result))|(V_VT(&v) != VT_BSTR))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	BSTR szClassName = SysAllocString(V_BSTR(&v));
	VariantClear(&v);

	/****************give it a Name property**********************************/
	V_VT(&v) = VT_BSTR;
	CString associationClassName(CString(szClassName)
						+CString(SMIR_MODULE_ASSOC_CLASS_NAME_POSTFIX));

	V_BSTR(&v)=associationClassName.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_NAME_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		SysFreeString(szClassName);
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}
	/****************give it a class property**********************************/
	//get the fully qualified class name
	//classes = "\\\\.\\root\\default\\SMIR:MS_SNMP_RFC1213_MIB_atTable";
	CString classPath(CString(SMIR_NAMESPACE_FROM_ROOT)
						+CString(COLON_STR)
						+CString(szClassName));

	SysFreeString(szClassName);

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=classPath.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_CLASS_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	/****************give it a group property**********************************/
	//get the fully qualified class name
	//group = "\\\\.\\root\\default\\SMIR:Module=\"RFC1213_MIB\"";
	CString groupPath(CString(SMIR_NAMESPACE_FROM_ROOT)
				+CString(COLON_STR)
				+CString(MODULE_NAMESPACE_NAME)
				+CString(DOT_STR)
				+CString(OLEMS_NAME_PROP)
				+CString(EQUALS_STR)
				+CString(QUOTE_STR)
				+CString(szModuleName)
				+CString(QUOTE_STR));

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=groupPath.AllocSysString();
	result = pInst->Put(SMIR_MODULE_ASSOC_MODULE_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);

	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}

	//now save it

	result = moServ->PutInstance(pInst, RESERVED_WBEM_FLAG, moContext,NULL);

	if ( moContext )
		moContext->Release () ;

	pInst->Release();
	moServ->Release();
	/*the query to find the classes is
	 *associators of {\\.\root\default\SMIR:Module="RFC1213_MIB"}
	     */
	return S_OK;
}

SCODE CModuleToNotificationClassAssociator :: Associate (

	CSmir *a_Smir,
	BSTR szModuleName, 
	ISmirNotificationClassHandle *hClass
)
{
	if ((NULL == hClass)||(NULL==szModuleName))
		return WBEM_E_FAILED;

	IWbemServices *	moServ = NULL ;
	IWbemContext *moContext = NULL ;
	SCODE result= CSmirAccess :: GetContext (a_Smir , &moContext);

	//open the root\default\SMIR namespace
	CSmirAccess :: Open(a_Smir,&moServ);

	//get an object
	IWbemClassObject *pClass = NULL ;
	CBString t_BStr ( SMIR_MODULE_ASSOC_NCLASS_NAME ) ;
	result = moServ->GetObject(t_BStr.GetString (), 0, 
									moContext,&pClass, NULL);

	if ((FAILED(result))||(NULL == pClass))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	IWbemClassObject *pInst = NULL ;
	result = pClass->SpawnInstance ( 0 , &pInst ) ;
	pClass->Release ();

	if ((FAILED(result))||(NULL==pInst))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	VARIANT v;
	VariantInit(&v);

	//Get the class name
	result  = ((CSmirNotificationClassHandle*)hClass)->m_pIMosClass->Get(OLEMS_CLASS_PROP, 
												RESERVED_WBEM_FLAG,  &v,NULL,NULL);

	if ((FAILED(result))|(V_VT(&v) != VT_BSTR))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	BSTR szClassName = SysAllocString(V_BSTR(&v));
	VariantClear(&v);

	/****************give it a Name property**********************************/
	V_VT(&v) = VT_BSTR;
	CString associationClassName(CString(szClassName)
						+CString(SMIR_MODULE_ASSOC_CLASS_NAME_POSTFIX));

	V_BSTR(&v)=associationClassName.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_NAME_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);

	if (FAILED(result))
	{
		SysFreeString(szClassName);
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}
	/****************give it a class property**********************************/
	//get the fully qualified class name
	//classes = "\\\\.\\root\\default\\SMIR:MS_SNMP_RFC1213_MIB_atTable";
	CString classPath(CString(SMIR_NAMESPACE_FROM_ROOT)
						+CString(COLON_STR)
						+CString(szClassName));

	SysFreeString(szClassName);

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=classPath.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_CLASS_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	/****************give it a module property**********************************/
	//get the fully qualified class name
	//module = "\\\\.\\root\\default\\SMIR:Module=\"RFC1213_MIB\"";
	CString modPath(CString(SMIR_NAMESPACE_FROM_ROOT)
				+CString(COLON_STR)
				+CString(MODULE_NAMESPACE_NAME)
				+CString(DOT_STR)
				+CString(OLEMS_NAME_PROP)
				+CString(EQUALS_STR)
				+CString(QUOTE_STR)
				+CString(szModuleName)
				+CString(QUOTE_STR));

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=modPath.AllocSysString();
	result = pInst->Put(SMIR_MODULE_ASSOC_MODULE_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);

	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}

	//now save it

	result = moServ->PutInstance(pInst, RESERVED_WBEM_FLAG, moContext,NULL);
	if ( moContext )
		moContext->Release () ;

	pInst->Release();
	moServ->Release();
	/*the query to find the classes is
	 *associators of {\\.\root\default\SMIR:Module="RFC1213_MIB"}
	     */
	return S_OK;
}

SCODE CModuleToExtNotificationClassAssociator :: Associate(

	CSmir *a_Smir,
	BSTR szModuleName, 
	ISmirExtNotificationClassHandle *hClass
)
{
	if ((NULL == hClass)||(NULL==szModuleName))
		return WBEM_E_FAILED;

	IWbemServices *	moServ = NULL ;
	IWbemContext *moContext = NULL ;
	SCODE result= CSmirAccess :: GetContext (a_Smir , &moContext);
	//open the root\default\SMIR namespace
	CSmirAccess :: Open(a_Smir,&moServ);

	//get an object
	IWbemClassObject *pClass = NULL ;
	CBString t_BStr ( SMIR_MODULE_ASSOC_EXTNCLASS_NAME ) ;
	result = moServ->GetObject(t_BStr.GetString (), 0, 
									moContext,&pClass, NULL);

	if ((FAILED(result))||(NULL == pClass))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	IWbemClassObject *pInst = NULL ;
	result = pClass->SpawnInstance ( 0 , &pInst ) ;
	pClass->Release ();

	if ((FAILED(result))||(NULL==pInst))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	VARIANT v;
	VariantInit(&v);

	//Get the class name
	result  = ((CSmirExtNotificationClassHandle*)hClass)->m_pIMosClass->Get(OLEMS_CLASS_PROP, 
												RESERVED_WBEM_FLAG,  &v,NULL,NULL);

	if ((FAILED(result))|(V_VT(&v) != VT_BSTR))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	BSTR szClassName = SysAllocString(V_BSTR(&v));
	VariantClear(&v);

	/****************give it a Name property**********************************/
	V_VT(&v) = VT_BSTR;
	CString associationClassName(CString(szClassName)
						+CString(SMIR_MODULE_ASSOC_CLASS_NAME_POSTFIX));

	V_BSTR(&v)=associationClassName.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_NAME_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		SysFreeString(szClassName);
		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}
	/****************give it a class property**********************************/
	//get the fully qualified class name
	//classes = "\\\\.\\root\\default\\SMIR:MS_SNMP_RFC1213_MIB_atTable";
	CString classPath(CString(SMIR_NAMESPACE_FROM_ROOT)
						+CString(COLON_STR)
						+CString(szClassName));

	SysFreeString(szClassName);

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=classPath.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_CLASS_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	/****************give it a module property**********************************/
	//get the fully qualified class name
	//module = "\\\\.\\root\\default\\SMIR:Module=\"RFC1213_MIB\"";
	CString modPath(CString(SMIR_NAMESPACE_FROM_ROOT)
				+CString(COLON_STR)
				+CString(MODULE_NAMESPACE_NAME)
				+CString(DOT_STR)
				+CString(OLEMS_NAME_PROP)
				+CString(EQUALS_STR)
				+CString(QUOTE_STR)
				+CString(szModuleName)
				+CString(QUOTE_STR));

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=modPath.AllocSysString();
	result = pInst->Put(SMIR_MODULE_ASSOC_MODULE_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);

	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}

	//now save it

	result = moServ->PutInstance(pInst, RESERVED_WBEM_FLAG, moContext,NULL);

	if ( moContext )
		moContext->Release () ;

	pInst->Release();
	moServ->Release();
	/*the query to find the classes is
	 *associators of {\\.\root\default\SMIR:Module="RFC1213_MIB"}
	     */
	return S_OK;
}

SCODE CSMIRToClassAssociator :: Associate (

	CSmir *a_Smir,
	ISmirClassHandle *hClass
)
{
	if (NULL == hClass)
		return WBEM_E_FAILED;

	IWbemServices *	moServ = NULL ;
	IWbemContext *moContext = NULL ;
	SCODE result= CSmirAccess :: GetContext (a_Smir , &moContext);
	//open the root\default\SMIR namespace
	CSmirAccess :: Open(a_Smir,&moServ);

	//get an object
	IWbemClassObject *pClass = NULL;
	CBString t_BStr ( SMIR_ASSOC_CLASS_NAME ) ;
	result = moServ->GetObject(t_BStr.GetString () , 0, 
									NULL,&pClass, NULL);

	if ((FAILED(result))||(NULL == pClass))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	//make an instance
	IWbemClassObject *pInst = NULL ;
	result = pClass->SpawnInstance ( 0 , &pInst ) ;
	pClass->Release ();

	if ((FAILED(result))||(NULL==pInst))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	VARIANT v;
	VariantInit(&v);

	//get the class name
	result  = ((CSmirClassHandle*)hClass)->m_pIMosClass->Get(OLEMS_CLASS_PROP, RESERVED_WBEM_FLAG,  &v,NULL,NULL);
	if ((FAILED(result))|(V_VT(&v) != VT_BSTR))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}

	BSTR szClassName = SysAllocString(V_BSTR(&v));
	VariantClear(&v);

	/****************give it a class property**********************************/
	//get the fully qualified class name
	//classes = "\\\\.\\root\\default\\SMIR:MS_SNMP_RFC1213_MIB_atTable";
	CString classPath(CString(SMIR_NAMESPACE_FROM_ROOT)
						+CString(COLON_STR)
						+CString(szClassName));

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=classPath.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_CLASS_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}
	/****************give it a Name property**********************************/
	V_VT(&v) = VT_BSTR;
	CString associationClassName(CString(szClassName)
						+CString(SMIR_ASSOC_CLASS_NAME_POSTFIX));

	SysFreeString(szClassName);

	V_BSTR(&v)=associationClassName.AllocSysString();
	result = pInst->Put(SMIR_X_ASSOC_NAME_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}
	/****************give it a smir property**********************************/
	//get the fully qualified class name
	//smir = "\\\\.\\root\\default\\SMIR";
	CString smirPath(SMIR_CLASS_ASSOCIATION_ENDPOINT);

	V_VT(&v) = VT_BSTR;
	V_BSTR(&v)=smirPath.AllocSysString();
	result = pInst->Put(SMIR_ASSOC_SMIR_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);
	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		pInst->Release();
		moServ->Release();
		return WBEM_E_FAILED;
	}
	
	//now save it

	result = moServ->PutInstance(pInst, RESERVED_WBEM_FLAG, moContext,NULL);

	if ( moContext )
		moContext->Release () ;
	pInst->Release();
	moServ->Release();
	/*the query to find the classes is
	 *associators of {\\.\root\default\SMIR\RFC1316-MIB:Group="charV1ObjectGroup"}
	 *or
	 *associators of {\\.\root\default\SMIR\RFC1213-MIB:Group="atV1ObjectGroup"}
		 */
	return S_OK;
}

SCODE CNotificationMapper :: Map (

	CSmir *a_Smir,
	IWbemClassObject *pObj, 
	enum NotificationMapperType type
)
{
	if (NULL == pObj)
		return WBEM_E_FAILED;

	IWbemServices *	moServ = NULL;
	IWbemContext *moContext = NULL ;
	SCODE result= CSmirAccess :: GetContext (a_Smir , &moContext);

	//open the root\default\SMIR namespace
	result = CSmirAccess :: Open(a_Smir,&moServ);

	if ((FAILED(result)) || (NULL == moServ))
	{
		if ( moContext )
			moContext->Release () ;

		return WBEM_E_FAILED;
	}

	//get an object
	IWbemClassObject *pClass = NULL;

	if (SNMP_NOTIFICATION_CLASS == type)
	{
		CBString t_BStr ( SMIR_NOTIFICATION_MAPPER ) ;
		result = moServ->GetObject(t_BStr.GetString (), 0, moContext, &pClass, NULL); 
	}
	else if (SNMP_EXT_NOTIFICATION_CLASS == type)
	{
		CBString t_BStr ( SMIR_EXT_NOTIFICATION_MAPPER ) ;
		result = moServ->GetObject(t_BStr.GetString (), 0, moContext,&pClass, NULL); 
	}

	if ((FAILED(result))||(NULL == pClass))
	{
		moServ->Release();
		if ( moContext )
			moContext->Release () ;

		return WBEM_E_FAILED;
	}

	IWbemClassObject *pInst = NULL ;
	result = pClass->SpawnInstance ( 0 , &pInst ) ;
	pClass->Release ();

	if ((FAILED(result))||(NULL==pInst))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		return WBEM_E_FAILED;
	}

	VARIANT v;
	VariantInit(&v);

	//Get the class name
	result  = pObj->Get(OLEMS_CLASS_PROP, RESERVED_WBEM_FLAG, &v, NULL, NULL);

	if ((FAILED(result))|(V_VT(&v) != VT_BSTR))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}
	
	/****************Set the eventclass property********************************/
	result = pInst->Put(SMIR_NOTIFICATION_CLASS_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);

	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	//Get the trapoid
	result  = pObj->Get(TRAPOID_PROP, RESERVED_WBEM_FLAG, &v, NULL, NULL);

	if ((FAILED(result))|(V_VT(&v) != VT_BSTR))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	/****************Set the trapoid property********************************/
	result = pInst->Put(SMIR_NOTIFICATION_TRAP_PROP,RESERVED_WBEM_FLAG, &v,0);
	VariantClear(&v);

	if (FAILED(result))
	{
		if ( moContext )
			moContext->Release () ;

		moServ->Release();
		pInst->Release();
		return WBEM_E_FAILED;
	}

	//now save it

	result = moServ->PutInstance(pInst, RESERVED_WBEM_FLAG, moContext,NULL);

	if ( moContext )
		moContext->Release () ;

	pInst->Release();
	moServ->Release();

	return S_OK;
}