/*++ Copyright (c) Microsoft Corporation Module Name: TRIGGERPROVIDER.CPP Abstract: Contains CTriggerProvider implementation. Author: Vasundhara .G Revision History: Vasundhara .G 9-oct-2k : Created It. --*/ #include "pch.h" #include "General.h" #include "EventConsumerProvider.h" #include "TriggerConsumer.h" #include "TriggerProvider.h" #include "resource.h" extern HMODULE g_hModule; // holds the value of the next trigger id #pragma data_seg(".ProviderSeg") _declspec(dllexport) DWORD m_dwNextTriggerID = 0; #pragma data_seg() CTriggerProvider::CTriggerProvider( ) /*++ Routine Description: Constructor for CTriggerProvider class for initialization. Arguments: None. Return Value: None. --*/ { // update the no. of provider instances count InterlockedIncrement( ( LPLONG ) &g_dwInstances ); // initialize the reference count variable m_dwCount = 0; // initializations m_pContext = NULL; m_pServices = NULL; m_pwszLocale = NULL; m_dwNextTriggerID = 0; m_MaxTriggers = FALSE; } CTriggerProvider::~CTriggerProvider( ) /*++ Routine Description: Destructor for CTriggerProvider class. Arguments: None. Return Value: None. --*/ { // release the services / namespace interface ( if exist ) SAFERELEASE( m_pServices ); // release the context interface ( if exist ) SAFERELEASE( m_pContext ); // if memory is allocated for storing locale information, free it if ( NULL != m_pwszLocale ) { delete [] m_pwszLocale; } // update the no. of provider instances count InterlockedDecrement( ( LPLONG ) &g_dwInstances ); } STDMETHODIMP CTriggerProvider::QueryInterface( IN REFIID riid, OUT LPVOID* ppv ) /*++ Routine Description: Returns a pointer to a specified interface on an object to which a client currently holds an interface pointer. Arguments: [IN] riid : Identifier of the interface being requested. [OUT] ppv : Address of pointer variable that receives the interface pointer requested in riid. Upon successful return, *ppvObject contains the requested interface pointer to the object. Return Value: NOERROR if the interface is supported. E_NOINTERFACE if not. --*/ { // initialy set to NULL *ppv = NULL; // check whether interface requested is one we have if ( IID_IUnknown == riid ) { // need IUnknown interface *ppv = this; } else if ( IID_IWbemEventConsumerProvider == riid ) { // need IEventConsumerProvider interface *ppv = static_cast( this ); } else if ( IID_IWbemServices == riid ) { // need IWbemServices interface *ppv = static_cast( this ); } else if ( IID_IWbemProviderInit == riid ) { // need IWbemProviderInit *ppv = static_cast( this ); } else { // request interface is not available return E_NOINTERFACE; } // update the reference count reinterpret_cast( *ppv )->AddRef(); return NOERROR; // inform success } STDMETHODIMP_(ULONG) CTriggerProvider::AddRef( void ) /*++ Routine Description: The AddRef method increments the reference count for an interface on an object. It should be called for every new copy of a pointer to an interface on a given object. Arguments: none. Return Value: Returns the value of the new reference count. --*/ { // increment the reference count ... thread safe return InterlockedIncrement( ( LPLONG ) &m_dwCount ); } STDMETHODIMP_(ULONG) CTriggerProvider::Release( void ) /*++ Routine Description: The Release method decreases the reference count of the object by 1. Arguments: none. Return Value: Returns the new reference count. --*/ { // decrement the reference count ( thread safe ) and check whether // there are some more references or not ... based on the result value DWORD dwCount = 0; dwCount = InterlockedDecrement( ( LPLONG ) &m_dwCount ); if ( 0 == dwCount ) { // free the current factory instance delete this; } // return the no. of instances references left return dwCount; } STDMETHODIMP CTriggerProvider::Initialize( IN LPWSTR wszUser, IN LONG lFlags, IN LPWSTR wszNamespace, IN LPWSTR wszLocale, IN IWbemServices* pNamespace, IN IWbemContext* pCtx, OUT IWbemProviderInitSink* pInitSink ) /*++ Routine Description: This is the implemention of IWbemProviderInit. The method is need to initialize with CIMOM. Arguments: [IN] wszUser : pointer to user name. [IN] lFlags : Reserved. [IN] wszNamespace : contains the namespace of WMI. [IN] wszLocale : Locale Name. [IN] pNamespace : pointer to IWbemServices. [IN] pCtx : IwbemContext pointer associated for initialization. [OUT] pInitSink : a pointer to IWbemProviderInitSink for reporting the initialization status. Return Value: returns HRESULT value. --*/ { HRESULT hRes = 0; IEnumWbemClassObject *pINTEConsumer = NULL; DWORD dwReturned = 0; DWORD dwTrigId = 0; VARIANT varTrigId; DWORD i = 0; if( ( NULL == pNamespace ) || ( NULL == pInitSink ) ) { // return failure return WBEM_E_FAILED; } try { // save the namespace interface ... will be useful at later stages m_pServices = pNamespace; m_pServices->AddRef(); // update the reference // also save the context interface ... will be userful at later stages ( if available ) if ( NULL != pCtx ) { m_pContext = pCtx; m_pContext->AddRef(); } // save the locale information ( if exist ) if ( NULL != wszLocale ) { m_pwszLocale = new WCHAR [ StringLength( wszLocale, 0 ) + 1 ]; if ( NULL == m_pwszLocale ) { // update the sink accordingly pInitSink->SetStatus( WBEM_E_FAILED, 0 ); // return failure return WBEM_E_OUT_OF_MEMORY; } } // Enumerate TriggerEventConsumer to get the Maximum trigger Id which can be later // used to generate unique trigger id value. hRes = m_pServices ->CreateInstanceEnum( _bstr_t(CONSUMER_CLASS), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, m_pContext, &pINTEConsumer); if (SUCCEEDED( hRes ) ) { dwReturned = 1; // Final Next will return with ulReturned = 0 while ( 0 != dwReturned ) { IWbemClassObject *pINTCons[5]; // Enumerate through the resultset. hRes = pINTEConsumer->Next( WBEM_INFINITE, 5, // return just one Logfile pINTCons, // pointer to Logfile &dwReturned ); // number obtained: one or zero if ( SUCCEEDED( hRes ) ) { // Get the trigger id value for( i = 0; i < dwReturned; i++ ) { VariantInit( &varTrigId ); hRes = pINTCons[i]->Get( TRIGGER_ID, 0, &varTrigId, 0, NULL ); SAFERELEASE( pINTCons[i] ); if ( SUCCEEDED( hRes ) ) { dwTrigId = ( DWORD )varTrigId.lVal; if( dwTrigId > m_dwNextTriggerID ) { m_dwNextTriggerID = dwTrigId; } } else { VariantClear( &varTrigId ); break; } VariantClear( &varTrigId ); } } else { break; } } //while // got triggerId so set it SAFERELEASE( pINTEConsumer ); } //Let CIMOM know your initialized //=============================== if ( SUCCEEDED( hRes ) ) { if( m_dwNextTriggerID >= MAX_TRIGGEID_VALUE ) { hRes = WBEM_E_FAILED; } else { m_dwNextTriggerID = m_dwNextTriggerID + 1; hRes = pInitSink->SetStatus( WBEM_S_INITIALIZED, 0 ); } } else { hRes = pInitSink->SetStatus( WBEM_E_FAILED, 0); } } catch(_com_error& e) { hRes = pInitSink->SetStatus( WBEM_E_FAILED, 0); return e.Error(); } return hRes; } STDMETHODIMP CTriggerProvider::ExecMethodAsync( IN const BSTR bstrObjectPath, IN const BSTR bstrMethodName, IN long lFlags, IN IWbemContext* pICtx, IN IWbemClassObject* pIInParams, OUT IWbemObjectSink* pIResultSink ) /*++ Routine Description: This is the Async function implementation. The methods supported is named CreateETrigger and DeleteETrigger. Arguments: [IN] bstrObjectPath : path of the object for which the method is executed. [IN] bstrMethodName : Name of the method for the object. [IN] lFlags : WBEM_FLAG_SEND_STATUS. [IN] pICtx : a pointer to IWbemContext. [IN] pIInParams : this points to an IWbemClassObject object that contains the properties acting as inbound parameters for method execution. [OUT] pIResultSink : The object sink receives the result of the method call. Return Value: returns HRESULT. --*/ { HRESULT hRes = 0; HRESULT hRes1 = NO_ERROR; IWbemClassObject *pIClass = NULL; IWbemClassObject *pIOutClass = NULL; IWbemClassObject *pIOutParams = NULL; VARIANT varTriggerName, varTriggerAction, varTriggerQuery, varTriggerDesc, varTemp, varRUser, varRPwd, varScheduledTaskName; DWORD dwTrigId = 0; LPTSTR lpResStr = NULL; try { //set out parameters hRes = m_pServices->GetObject( _bstr_t( CONSUMER_CLASS ), 0, pICtx, &pIClass, NULL ); if( FAILED( hRes ) ) { pIResultSink->SetStatus( 0, hRes, NULL, NULL ); return hRes; } // This method returns values, and so create an instance of the // output argument class. hRes = pIClass->GetMethod( bstrMethodName, 0, NULL , &pIOutClass ); SAFERELEASE( pIClass ); if( FAILED( hRes ) ) { pIResultSink->SetStatus( 0, hRes, NULL, NULL ); return hRes; } hRes = pIOutClass->SpawnInstance( 0, &pIOutParams ); SAFERELEASE( pIOutClass ); if( FAILED( hRes ) ) { pIResultSink->SetStatus( 0, hRes, NULL, NULL ); return hRes; } VariantInit( &varTriggerName ); //Check the method name if( ( StringCompare( bstrMethodName, CREATE_METHOD_NAME, TRUE, 0 ) == 0 ) || ( StringCompare( bstrMethodName, CREATE_METHOD_NAME_EX, TRUE, 0 ) == 0 ) ) { // if client has called CreateETrigger then // parse input params to get trigger name, trigger desc, trigger action // and trigger query for creating new instances of TriggerEventConsumer, // __EventFilter and __FilterToConsumerBinding classes //initialize variables VariantInit( &varTriggerAction ); VariantInit( &varTriggerQuery ); VariantInit( &varTriggerDesc ); VariantInit( &varRUser ); VariantInit( &varRPwd ); //Retrieve Trigger Name parameter from input params hRes = pIInParams->Get( IN_TRIGGER_NAME, 0, &varTriggerName, NULL, NULL ); if( SUCCEEDED( hRes ) ) { //Retrieve Trigger Action parameter from input params hRes = pIInParams->Get( IN_TRIGGER_ACTION, 0, &varTriggerAction, NULL, NULL ); if( SUCCEEDED( hRes ) ) { //Retrieve Trigger Query parameter from input params hRes = pIInParams->Get( IN_TRIGGER_QUERY, 0, &varTriggerQuery, NULL, NULL ); if( SUCCEEDED( hRes ) ) { //Retrieve Trigger Description parameter from input params hRes = pIInParams->Get( IN_TRIGGER_DESC, 0, &varTriggerDesc, NULL, NULL ); if( SUCCEEDED( hRes ) ) { hRes = pIInParams->Get( IN_TRIGGER_USER, 0, &varRUser, NULL, NULL ); if( SUCCEEDED( hRes ) ) { EnterCriticalSection( &g_critical_sec ); hRes = ValidateParams( varTriggerName, varTriggerAction, varTriggerQuery, varRUser ); if( SUCCEEDED( hRes ) ) { hRes = pIInParams->Get( IN_TRIGGER_PWD, 0, &varRPwd, NULL, NULL ); if( SUCCEEDED( hRes ) ) { //call create trigger function to create the instances hRes = CreateTrigger( varTriggerName, varTriggerDesc, varTriggerAction, varTriggerQuery, varRUser, varRPwd, &hRes1 ); // changed on 07/12/02 to send error instead of warning if account info not set if( ( SUCCEEDED( hRes ) ) || ( ERROR_TASK_SCHDEULE_SERVICE_STOP == hRes1 ) ) { // increment the class member variable by one to get the new unique trigger id //for the next instance if( MAX_TRIGGEID_VALUE > m_dwNextTriggerID ) { m_dwNextTriggerID = m_dwNextTriggerID + 1; } else { m_MaxTriggers = TRUE; } } } } LeaveCriticalSection( &g_critical_sec ); } } } } } VariantClear( &varTriggerAction ); VariantClear( &varRUser ); VariantClear( &varRPwd ); VariantClear( &varTriggerDesc ); VariantClear( &varTriggerQuery ); } else if( ( StringCompare( bstrMethodName, DELETE_METHOD_NAME, TRUE, 0 ) == 0 ) || ( StringCompare( bstrMethodName, DELETE_METHOD_NAME_EX, TRUE, 0 ) == 0 ) ) { //Retrieve Trigger ID parameter from input params hRes = pIInParams->Get( IN_TRIGGER_NAME, 0, &varTriggerName, NULL, NULL ); if( SUCCEEDED( hRes ) ) { EnterCriticalSection( &g_critical_sec ); //call Delete trigger function to delete the instances hRes = DeleteTrigger( varTriggerName, &dwTrigId ); LeaveCriticalSection( &g_critical_sec ); } } else if( ( StringCompare( bstrMethodName, QUERY_METHOD_NAME, TRUE, 0 ) == 0 ) || ( StringCompare( bstrMethodName, QUERY_METHOD_NAME_EX, TRUE, 0 ) == 0 ) ) { VariantInit( &varScheduledTaskName ); VariantInit( &varRUser ); //Retrieve schedule task name parameter from input params hRes = pIInParams->Get( IN_TRIGGER_TSCHDULER, 0, &varScheduledTaskName, NULL, NULL ); if( SUCCEEDED( hRes ) ) { EnterCriticalSection( &g_critical_sec ); //call query trigger function to query the runasuser CHString szRunAsUser = L""; hRes = CoImpersonateClient(); if( SUCCEEDED( hRes ) ) { varRUser.vt = VT_BSTR; varRUser.bstrVal = SysAllocString( L"" ); hRes = pIOutParams->Put( OUT_RUNAS_USER , 0, &varRUser, 0 ); VariantClear( &varRUser ); if( SUCCEEDED( hRes ) ) { hRes = QueryTrigger( varScheduledTaskName, szRunAsUser ); if( SUCCEEDED( hRes ) ) { VariantInit( &varRUser ); varRUser.vt = VT_BSTR; varRUser.bstrVal = SysAllocString( szRunAsUser ); hRes = pIOutParams->Put( OUT_RUNAS_USER , 0, &varRUser, 0 ); } } } CoRevertToSelf(); LeaveCriticalSection( &g_critical_sec ); } VariantClear( &varScheduledTaskName ); VariantClear( &varRUser ); } else { hRes = WBEM_E_INVALID_PARAMETER; } if( ( StringCompare( bstrMethodName, CREATE_METHOD_NAME, TRUE, 0 ) == 0 ) || ( StringCompare( bstrMethodName, CREATE_METHOD_NAME_EX, TRUE, 0 ) == 0 ) ) { lpResStr = ( LPTSTR ) AllocateMemory( MAX_RES_STRING1 ); if ( lpResStr != NULL ) { // changed on 07/12/02 to log error if account info is not set instead of success if( ( SUCCEEDED( hRes ) ) || ( ERROR_TASK_SCHDEULE_SERVICE_STOP == hRes1 ) ) { LoadStringW( g_hModule, IDS_CREATED, lpResStr, GetBufferSize(lpResStr)/sizeof(WCHAR) ); if( hRes1 != NO_ERROR )// write invalid user into log file { LPTSTR lpResStr1 = NULL; lpResStr1 = ( LPTSTR ) AllocateMemory( MAX_RES_STRING1 ); if ( lpResStr1 != NULL ) { if( hRes1 == ERROR_TASK_SCHDEULE_SERVICE_STOP ) { hRes = WBEM_S_NO_ERROR; LoadStringW( g_hModule,IDS_INFO_SERVICE_STOPPED, lpResStr1, GetBufferSize(lpResStr1)/sizeof(WCHAR) ); StringConcat( lpResStr, lpResStr1, GetBufferSize(lpResStr)/sizeof(WCHAR) ); } FreeMemory( (LPVOID*)&lpResStr1 ); } } ErrorLog( lpResStr, ( LPWSTR )_bstr_t( varTriggerName ), ( m_dwNextTriggerID - 1 ) ); } else { LoadStringW( g_hModule, IDS_CREATE_FAILED, lpResStr, GetBufferSize(lpResStr)/sizeof(WCHAR) ); ErrorLog( lpResStr, ( LPWSTR )_bstr_t( varTriggerName ), ( m_dwNextTriggerID - 1 ) ); } FreeMemory( (LPVOID*)&lpResStr ); } else { hRes = E_OUTOFMEMORY; } } else if( ( StringCompare( bstrMethodName, DELETE_METHOD_NAME, TRUE, 0 ) == 0 ) || ( StringCompare( bstrMethodName, DELETE_METHOD_NAME_EX, TRUE, 0 ) == 0 ) ) { lpResStr = ( LPTSTR ) AllocateMemory( MAX_RES_STRING1 ); if ( lpResStr != NULL ) { if(( SUCCEEDED( hRes ) ) ) { LoadStringW( g_hModule, IDS_DELETED, lpResStr, GetBufferSize(lpResStr)/sizeof(WCHAR) ); ErrorLog( lpResStr, ( LPWSTR )_bstr_t( varTriggerName ), dwTrigId ); } else { LoadStringW( g_hModule, IDS_DELETE_FAILED, lpResStr, GetBufferSize(lpResStr)/sizeof(WCHAR) ); ErrorLog( lpResStr,( LPWSTR )_bstr_t( varTriggerName ), dwTrigId ); } FreeMemory( (LPVOID*)&lpResStr ); } else { hRes = E_OUTOFMEMORY; } } VariantClear( &varTriggerName ); VariantInit( &varTemp ); V_VT( &varTemp ) = VT_I4; if ( NO_ERROR != hRes1 ) { if( StringCompare( bstrMethodName, CREATE_METHOD_NAME, TRUE, 0 ) == 0 ) { V_I4( &varTemp ) = WARNING_INVALID_USER; } else { V_I4( &varTemp ) = hRes1; } } else { if( StringCompare( bstrMethodName, CREATE_METHOD_NAME, TRUE, 0 ) == 0 ) { if ( hRes == ERROR_TRIGNAME_ALREADY_EXIST_EX ) { hRes = ( HRESULT )ERROR_TRIGNAME_ALREADY_EXIST; } } if( StringCompare( bstrMethodName, DELETE_METHOD_NAME, TRUE, 0 ) == 0 ) { if ( hRes == ERROR_TRIGGER_NOT_FOUND_EX ) { hRes = ( HRESULT )ERROR_TRIGGER_NOT_FOUND; } if ( hRes == ERROR_TRIGGER_NOT_DELETED_EX ) { hRes = ( HRESULT )ERROR_TRIGGER_NOT_DELETED; } } if( StringCompare( bstrMethodName, QUERY_METHOD_NAME, TRUE, 0 ) == 0 ) { if ( hRes == ERROR_TRIGGER_CORRUPTED_EX ) { hRes = WBEM_NO_ERROR; } if ( hRes == ERROR_INVALID_USER_EX ) { hRes = WBEM_NO_ERROR; } } V_I4( &varTemp ) = hRes; } // set out params hRes = pIOutParams->Put( RETURN_VALUE , 0, &varTemp, 0 ); VariantClear( &varTemp ); if( SUCCEEDED( hRes ) ) { // Send the output object back to the client via the sink. Then hRes = pIResultSink->Indicate( 1, &pIOutParams ); } //release all the resources SAFERELEASE( pIOutParams ); hRes = pIResultSink->SetStatus( 0, WBEM_S_NO_ERROR, NULL, NULL ); } catch(_com_error& e) { VariantClear( &varTriggerName ); FREESTRING( lpResStr ); SAFERELEASE( pIOutParams ); pIResultSink->SetStatus( 0, hRes, NULL, NULL ); return e.Error(); } catch( CHeap_Exception ) { VariantClear( &varTriggerName ); FREESTRING( lpResStr ); SAFERELEASE( pIOutParams ); hRes = E_OUTOFMEMORY; pIResultSink->SetStatus( 0, hRes, NULL, NULL ); return hRes; } return hRes; } HRESULT CTriggerProvider::CreateTrigger( IN VARIANT varTName, IN VARIANT varTDesc, IN VARIANT varTAction, IN VARIANT varTQuery, IN VARIANT varRUser, IN VARIANT varRPwd, OUT HRESULT *phRes ) /*++ Routine Description: This routine creates the instance of TriggerEventConsumer, __EventFilter and __FilterToConsumerBinding classes. Arguments: [IN] varTName : Trigger Name. [IN] VarTDesc : Trigger Description. [IN] varTAction : Trigger Action. [IN] varTQuery : Trigger Query. [IN] varRUser : Run as user name. [IN] varRPwd : Run as Password. [OUT] phRes : Return value of scedule task creation. Return Value: S_OK if successful. Otherwise failure error code. --*/ { IWbemClassObject *pINtLogEventClass = 0; IWbemClassObject *pIFilterClass = 0; IWbemClassObject *pIBindClass = 0; IWbemClassObject *pINewInstance = 0; IEnumWbemClassObject *pIEnumClassObject = 0; HRESULT hRes = 0; DWORD dwTId = 0; VARIANT varTemp; TCHAR szTemp[MAX_RES_STRING1]; TCHAR szTemp1[MAX_RES_STRING1]; TCHAR szFName[MAX_RES_STRING1]; SYSTEMTIME SysTime; BOOL bInvalidUser = FALSE; try { _bstr_t bstrcurInst; _bstr_t bstrcurInst1; //initialize memory for temporary variables SecureZeroMemory( szTemp, MAX_RES_STRING1 * sizeof( TCHAR ) ); SecureZeroMemory( szTemp1, MAX_RES_STRING1 * sizeof( TCHAR ) ); SecureZeroMemory( szFName, MAX_RES_STRING1 * sizeof( TCHAR ) ); VariantInit( &varTemp ); if ( NULL != phRes ) { *phRes = S_OK; } // changed on 07/12/02 just moved the block of code /************************************************************************** CREATING TriggerEventConsumer INSTANCE ***************************************************************************/ //get NTEventConsumer class object hRes =m_pServices->GetObject( _bstr_t( CONSUMER_CLASS ), 0, 0, &pINtLogEventClass, NULL ); //if unable to get the object of TriggerEventConsumer return error if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass );// safer side return hRes; } // Create a new instance. pINewInstance = NULL; hRes = pINtLogEventClass->SpawnInstance( 0, &pINewInstance ); SAFERELEASE( pINtLogEventClass ); // Don't need the class any more // if unable to spawn a instance return back to caller if( FAILED( hRes ) ) { SAFERELEASE( pINewInstance ); return hRes; } //get the unique trigger id by enumerating CmdTriggerConsumer class. if there are no triggers then // intialize the trigger id to 1 hRes = m_pServices->ExecQuery( _bstr_t( QUERY_LANGUAGE ), _bstr_t( INSTANCE_EXISTS_QUERY ), WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pIEnumClassObject ); if( FAILED( hRes ) ) { SAFERELEASE( pIEnumClassObject ); SAFERELEASE( pINewInstance ); return hRes; } DWORD dwReturned = 0; IWbemClassObject *pINTCons = NULL; // Enumerate through the resultset. hRes = pIEnumClassObject->Next( WBEM_INFINITE, 1, // return just one service &pINTCons, // pointer to service &dwReturned ); // number obtained: one or zero if ( SUCCEEDED( hRes ) && ( dwReturned == 1 ) ) { SAFERELEASE( pINTCons ); } // If Service Succeeded else { m_dwNextTriggerID = 1; } SAFERELEASE( pIEnumClassObject ); dwTId = m_dwNextTriggerID; VariantInit(&varTemp); varTemp.vt = VT_I4; varTemp.lVal = dwTId; // set the trigger id property of NTEventConsumer hRes = pINewInstance->Put( TRIGGER_ID, 0, &varTemp, 0 ); VariantClear( &varTemp ); //if failed to set the property return error if( FAILED( hRes ) ) { SAFERELEASE( pINewInstance ); return hRes; } // set Triggername property. hRes = pINewInstance->Put( TRIGGER_NAME, 0, &varTName, 0 ); //if failed to set the property return error if( FAILED( hRes ) ) { SAFERELEASE( pINewInstance ); return hRes; } // set action property hRes = pINewInstance->Put( TRIGGER_ACTION, 0, &varTAction, 0 ); //if failed to set the property return error if( FAILED( hRes ) ) { SAFERELEASE( pINewInstance ); return hRes; } //set desc property hRes = pINewInstance->Put( TRIGGER_DESC, 0, &varTDesc, 0 ); //if failed to set the property return error if( FAILED( hRes ) ) { SAFERELEASE( pINewInstance ); return hRes; } CHString szScheduler = L""; CHString szRUser = (LPCWSTR)_bstr_t(varRUser.bstrVal); { do { GetUniqueTScheduler( szScheduler, m_dwNextTriggerID, varTName ); hRes = CoImpersonateClient(); if( FAILED( hRes ) ) { SAFERELEASE( pINewInstance ); return hRes; } hRes = SetUserContext( varRUser, varRPwd, varTAction, szScheduler ); CoRevertToSelf(); if( HRESULT_FROM_WIN32 (ERROR_FILE_EXISTS ) != hRes ) { break; } }while( 1 ); if( FAILED( hRes ) ) { // changed on 07/12/02 not to handle user info not set as warning but as error if( hRes == ERROR_TASK_SCHDEULE_SERVICE_STOP ) //to send a warning msg to client { *phRes = hRes; } else { SAFERELEASE( pINewInstance ); return hRes; } } } VariantInit(&varTemp); varTemp.vt = VT_BSTR; varTemp.bstrVal = SysAllocString( szScheduler ); hRes = pINewInstance->Put( TASK_SHEDULER, 0, &varTemp, 0 ); VariantClear( &varTemp ); if( FAILED( hRes ) ) { SAFERELEASE( pINewInstance ); return hRes; } // Write the instance to WMI. hRes = m_pServices->PutInstance( pINewInstance, 0, 0, NULL ); SAFERELEASE( pINewInstance ); //if putinstance failed return error if( FAILED( hRes ) ) { return hRes; } //get the current instance for binding it with __FilterToConsumerBinding class StringCchPrintf( szTemp, SIZE_OF_ARRAY( szTemp ), BIND_CONSUMER_PATH, dwTId); bstrcurInst1 = _bstr_t( szTemp ); pINtLogEventClass = NULL; hRes = m_pServices->GetObject( bstrcurInst1, 0L, NULL, &pINtLogEventClass, NULL ); //if unable to get the current instance return error if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass ); return hRes; } /************************************************************************** CREATING __EventFilter INSTANCE ***************************************************************************/ // get EventFilter class object hRes = m_pServices->GetObject( _bstr_t( FILTER_CLASS ), 0, 0, &pIFilterClass, NULL ); if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass ); SAFERELEASE( pIFilterClass ); return hRes; } // Create a new instance. hRes = pIFilterClass->SpawnInstance( 0, &pINewInstance ); SAFERELEASE( pIFilterClass ); // Don't need the class any more //return error if unable to spawn a new instance of EventFilter class if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass ); SAFERELEASE( pINewInstance ); return hRes; } // set query property for the new instance hRes = pINewInstance->Put( FILTER_QUERY, 0, &varTQuery, 0 ); //if failed to set the property return error if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass ); SAFERELEASE( pINewInstance ); return hRes; } VariantInit( &varTemp ); varTemp.vt = VT_BSTR; varTemp.bstrVal = SysAllocString( QUERY_LANGUAGE ); // set query language property for the new instance . hRes = pINewInstance->Put( FILTER_QUERY_LANGUAGE, 0, &varTemp, 0 ); VariantClear( &varTemp ); //if failed to set the property return error if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass ); SAFERELEASE( pINewInstance ); return hRes; } //generate unique name for name key property of EventFilter class by concatinating // current system date and time GetSystemTime( &SysTime ); StringCchPrintf( szTemp, SIZE_OF_ARRAY( szTemp ), FILTER_UNIQUE_NAME, m_dwNextTriggerID, SysTime.wHour, SysTime.wMinute, SysTime.wSecond, SysTime.wMonth, SysTime.wDay, SysTime.wYear ); //set Filter name property VariantInit( &varTemp ); varTemp.vt = VT_BSTR; varTemp.bstrVal = SysAllocString( szTemp ); hRes = pINewInstance->Put( FILTER_NAME, 0, &varTemp, 0 ); VariantClear( &varTemp ); //if failed to set the property return error if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass ); SAFERELEASE( pINewInstance ); return hRes; } // Write the instance to WMI. hRes = m_pServices->PutInstance( pINewInstance, 0, NULL, NULL ); SAFERELEASE( pINewInstance ); //if putinstance failed return error if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass ); return hRes; } //get the current Eventfilter instance for binding filter to consumer StringCchPrintf( szTemp1, SIZE_OF_ARRAY( szTemp1 ), BIND_FILTER_PATH ); bstrcurInst = _bstr_t(szTemp1) + _bstr_t(szTemp) + _bstr_t(BACK_SLASH); pIFilterClass = NULL; hRes = m_pServices->GetObject( bstrcurInst, 0L, NULL, &pIFilterClass, NULL ); //unable to get the current instance object return error if( FAILED( hRes ) ) { SAFERELEASE( pINtLogEventClass ); SAFERELEASE( pIFilterClass ); return hRes; } /************************************************************************** BINDING FILTER TO CONSUMER ***************************************************************************/ // if association class exists... if( ( hRes = m_pServices->GetObject( _bstr_t( BINDINGCLASS ), 0L, NULL, &pIBindClass, NULL ) ) == S_OK ) { // spawn a new instance. pINewInstance = NULL; if( ( hRes = pIBindClass->SpawnInstance( 0, &pINewInstance ) ) == WBEM_S_NO_ERROR ) { // set consumer instance name if ( ( hRes = pINtLogEventClass->Get( REL_PATH, 0L, &varTemp, NULL, NULL ) ) == WBEM_S_NO_ERROR ) { hRes = pINewInstance->Put( CONSUMER_BIND, 0, &varTemp, 0 ); VariantClear( &varTemp ); // set Filter ref if ( ( hRes = pIFilterClass->Get( REL_PATH, 0L, &varTemp, NULL, NULL ) ) == WBEM_S_NO_ERROR ) { hRes = pINewInstance->Put( FILTER_BIND, 0, &varTemp, 0 ); VariantClear( &varTemp ); // putInstance hRes = m_pServices->PutInstance( pINewInstance, WBEM_FLAG_CREATE_OR_UPDATE, NULL, NULL ); } } SAFERELEASE( pINewInstance ); SAFERELEASE( pINtLogEventClass ); // Don't need the class any more SAFERELEASE( pIFilterClass ); // Don't need the class any more SAFERELEASE( pIBindClass ); } else { SAFERELEASE( pINtLogEventClass ); // Don't need the class any more SAFERELEASE( pIFilterClass ); // Don't need the class any more SAFERELEASE( pIBindClass ); } } else { SAFERELEASE( pINtLogEventClass ); // Don't need the class any more SAFERELEASE( pIFilterClass ); // Don't need the class any more } } catch(_com_error& e) { SAFERELEASE( pINewInstance ); SAFERELEASE( pINtLogEventClass ); SAFERELEASE( pIFilterClass ); SAFERELEASE( pIBindClass ); SAFERELEASE( pIEnumClassObject ); return e.Error(); } catch( CHeap_Exception ) { SAFERELEASE( pINewInstance ); SAFERELEASE( pINtLogEventClass ); SAFERELEASE( pIFilterClass ); SAFERELEASE( pIBindClass ); SAFERELEASE( pIEnumClassObject ); return E_OUTOFMEMORY; } return hRes; } HRESULT CTriggerProvider::DeleteTrigger( IN VARIANT varTName, OUT DWORD *dwTrigId ) /*++ Routine Description: This routine deletes the instance of TriggerEventConsumer, __EventFilter and __FilterToConsumerBinding classes. Arguments: [IN] varTName : Trigger Name. [OUT] dwTrigId : Trigger id. Return Value: WBEM_S_NO_ERROR if successful. Otherwise failure error code. --*/ { HRESULT hRes = 0; IEnumWbemClassObject *pIEventBinder = NULL; IWbemClassObject *pINTCons = NULL; DWORD dwReturned = 1; DWORD i =0; DWORD j = 0; TCHAR szTemp[MAX_RES_STRING1]; TCHAR szTemp1[MAX_RES_STRING1]; VARIANT varTemp; BSTR bstrFilInst = NULL; DWORD dwFlag = 0; wchar_t *szwTemp2 = NULL; wchar_t szwFilName[MAX_RES_STRING1]; try { _bstr_t bstrBinInst; CHString strTScheduler = L""; SecureZeroMemory( szTemp, MAX_RES_STRING1 * sizeof( TCHAR ) ); SecureZeroMemory( szTemp1, MAX_RES_STRING1 * sizeof( TCHAR ) ); SecureZeroMemory( szwFilName, MAX_RES_STRING1 * sizeof( TCHAR ) ); StringCchPrintf( szTemp, SIZE_OF_ARRAY( szTemp ), TRIGGER_INSTANCE_NAME, varTName.bstrVal ); hRes = m_pServices->ExecQuery( _bstr_t( QUERY_LANGUAGE ), _bstr_t( szTemp ), WBEM_FLAG_RETURN_IMMEDIATELY| WBEM_FLAG_FORWARD_ONLY, NULL, &pIEventBinder ); SecureZeroMemory( szTemp, MAX_RES_STRING1 * sizeof( TCHAR ) ); if( FAILED( hRes ) ) { return hRes; } while ( ( 1 == dwReturned ) && ( 0 == dwFlag ) ) { // Enumerate through the resultset. hRes = pIEventBinder->Next( WBEM_INFINITE, 1, // return just one service &pINTCons, // pointer to service &dwReturned ); // number obtained: one or zero if ( SUCCEEDED( hRes ) && ( 1 == dwReturned ) ) { dwFlag = 1; } // If Service Succeeded } SAFERELEASE( pIEventBinder ); if( 0 == dwFlag ) { SAFERELEASE( pINTCons ); return ERROR_TRIGGER_NOT_FOUND_EX; } VariantInit( &varTemp ); hRes = pINTCons->Get( TRIGGER_ID, 0, &varTemp, 0, NULL ); if (FAILED( hRes ) ) { SAFERELEASE( pINTCons ); return hRes; } *dwTrigId = ( DWORD )varTemp.lVal; VariantClear( &varTemp ); hRes = pINTCons->Get( TASK_SHEDULER, 0, &varTemp, 0, NULL ); if (FAILED( hRes ) ) { SAFERELEASE( pINTCons ); return hRes; } SAFERELEASE( pINTCons ); strTScheduler = (LPCWSTR) _bstr_t(varTemp.bstrVal); VariantClear( &varTemp ); if( strTScheduler.GetLength() > 0 ) { hRes = CoImpersonateClient(); if( FAILED( hRes ) ) { return hRes; } dwReturned = 0; hRes = DeleteTaskScheduler( strTScheduler ); if ( FAILED( hRes ) && ( ERROR_TRIGGER_CORRUPTED_EX != hRes ) ) { CoRevertToSelf(); return hRes; } hRes = CoRevertToSelf(); } StringCchPrintf( szTemp, SIZE_OF_ARRAY( szTemp ), BIND_CONSUMER_PATH, *dwTrigId ); //enumerate the binding class hRes = m_pServices->CreateInstanceEnum( _bstr_t(BINDINGCLASS), WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY, NULL, &pIEventBinder ); if ( SUCCEEDED( hRes ) ) { dwReturned = 1; dwFlag = 0; //loop through all the instances of binding class to find that trigger //id specified. If found loop out and proceed else return error // Final Next will return with ulReturned = 0 while ( ( 1 == dwReturned ) && ( 0 == dwFlag ) ) { IWbemClassObject *pIBind = NULL; // Enumerate through the resultset. hRes = pIEventBinder->Next( WBEM_INFINITE, 1, // return just one Logfile &pIBind, // pointer to Logfile &dwReturned ); // number obtained: one or zero if ( SUCCEEDED( hRes ) && ( 1 == dwReturned ) ) { VariantInit(&varTemp); //get consumer property of binding class hRes = pIBind->Get( CONSUMER_BIND, 0, &varTemp, 0, NULL ); if ( SUCCEEDED( hRes ) ) { if (varTemp.vt != VT_NULL && varTemp.vt != VT_EMPTY) { CHString strTemp; strTemp = varTemp.bstrVal; //compare with the inputed value if( StringCompare( szTemp, strTemp, TRUE, 0 ) == 0 ) { VariantClear( &varTemp ); //get the filter property hRes = pIBind->Get( FILTER_BIND, 0, &varTemp, 0, NULL ); if ( hRes != WBEM_S_NO_ERROR ) { SAFERELEASE( pIBind ); break; } bstrFilInst = SysAllocString( varTemp.bstrVal ); dwFlag = 1; } } else { SAFERELEASE( pIBind ); break; } } else { SAFERELEASE( pIBind ); break; } SAFERELEASE( pIBind ); VariantClear( &varTemp ); } else { break; } } //end of while SAFERELEASE( pIEventBinder ); } else { return( hRes ); } //if instance has been found delete the instances from consumer,filter // and binding class if( 1 == dwFlag ) { //get the key properties for binding class StringCchPrintf( szTemp1, SIZE_OF_ARRAY( szTemp1 ), FILTER_PROP, szTemp ); szwTemp2 = (wchar_t *) bstrFilInst; //manpulate the filter property value to insert the filter name property // value in quotes i =0; while( szwTemp2[i] != EQUAL ) { i++; } i += 2; j = 0; while( szwTemp2[i] != DOUBLE_QUOTE ) { szwFilName[j] = ( wchar_t )szwTemp2[i]; i++; j++; } szwFilName[j] = END_OF_STRING; bstrBinInst = _bstr_t( szTemp1 ) + _bstr_t( szwFilName ) + _bstr_t(DOUBLE_SLASH); //got it so delete the instance hRes = m_pServices->DeleteInstance( bstrBinInst, 0, 0, NULL ); if( FAILED( hRes ) ) { SysFreeString( bstrFilInst ); return hRes; } //deleting instance from EventFilter class hRes = m_pServices->DeleteInstance( bstrFilInst, 0, 0, NULL ); if( FAILED( hRes ) ) { SysFreeString( bstrFilInst ); return hRes; } //deleting instance from TriggerEventConsumer Class hRes = m_pServices->DeleteInstance( _bstr_t(szTemp), 0, 0, NULL ); if( FAILED( hRes ) ) { SysFreeString( bstrFilInst ); return hRes; } SysFreeString( bstrFilInst ); } else { return ERROR_TRIGGER_NOT_FOUND_EX; } } catch(_com_error& e) { SAFERELEASE( pINTCons ); SAFERELEASE( pIEventBinder ); return e.Error(); } catch( CHeap_Exception ) { SAFERELEASE( pINTCons ); SAFERELEASE( pIEventBinder ); return E_OUTOFMEMORY; } return hRes; } HRESULT CTriggerProvider::QueryTrigger( IN VARIANT varScheduledTaskName, OUT CHString &szRunAsUser ) /*++ Routine Description: This routine queries task scheduler for account information Arguments: [IN] varScheduledTaskName : Task scheduler name. [OUT] szRunAsUser : stores account information. Return Value: WBEM_S_NO_ERROR if successful. Otherwise failure error code. --*/ { HRESULT hRes = 0; ITaskScheduler *pITaskScheduler = NULL; IEnumWorkItems *pIEnum = NULL; ITask *pITask = NULL; LPWSTR *lpwszNames = NULL; DWORD dwFetchedTasks = 0; DWORD dwTaskIndex = 0; TCHAR szActualTask[MAX_STRING_LENGTH] = NULL_STRING; try { hRes = GetTaskScheduler(&pITaskScheduler); if ( FAILED( hRes ) ) { SAFERELEASE( pITaskScheduler ); return hRes; } hRes = pITaskScheduler->SetTargetComputer( NULL ); if( FAILED( hRes ) ) { SAFERELEASE( pITaskScheduler ); return hRes; } hRes = pITaskScheduler->Enum( &pIEnum ); if( FAILED( hRes ) ) { SAFERELEASE( pITaskScheduler ); return hRes; } while ( SUCCEEDED( pIEnum->Next( 1, &lpwszNames, &dwFetchedTasks ) ) && (dwFetchedTasks != 0)) { dwTaskIndex = dwFetchedTasks-1; StringCopy( szActualTask, lpwszNames[ --dwFetchedTasks ], SIZE_OF_ARRAY( szActualTask ) ); // Parse the TaskName to remove the .job extension. szActualTask[StringLength( szActualTask, 0 ) - StringLength( JOB, 0 ) ] = NULL_CHAR; StrTrim( szActualTask, TRIM_SPACES ); CHString strTemp; strTemp = varScheduledTaskName.bstrVal; if( StringCompare( szActualTask, strTemp, TRUE, 0 ) == 0 ) { hRes = pITaskScheduler->Activate(lpwszNames[dwTaskIndex],IID_ITask, (IUnknown**) &pITask); CoTaskMemFree( lpwszNames[ dwFetchedTasks ] ); CoTaskMemFree( lpwszNames ); pIEnum->Release(); SAFERELEASE( pITaskScheduler ); if( SUCCEEDED( hRes ) ) { LPWSTR lpwszUser = NULL; hRes = pITask->GetAccountInformation( &lpwszUser ); if( SUCCEEDED( hRes ) ) { if( 0 == StringLength( ( LPWSTR ) lpwszUser, 0 ) ) { szRunAsUser = L"NT AUTHORITY\\SYSTEM"; } else { szRunAsUser = ( LPWSTR ) lpwszUser; } SAFERELEASE( pITask ); return hRes; } else { SAFERELEASE( pITask ); return hRes; } } else { if( 0x80070005 == hRes ) { return ERROR_INVALID_USER_EX; } else { return hRes; } } } CoTaskMemFree( lpwszNames[ dwFetchedTasks ] ); CoTaskMemFree( lpwszNames ); } pIEnum->Release(); SAFERELEASE( pITaskScheduler ); } catch(_com_error& e) { SAFERELEASE( pITask ); SAFERELEASE( pITaskScheduler ); SAFERELEASE( pIEnum ); return e.Error(); } catch( CHeap_Exception ) { SAFERELEASE( pITask ); SAFERELEASE( pITaskScheduler ); SAFERELEASE( pIEnum ); return E_OUTOFMEMORY; } return ERROR_TRIGGER_CORRUPTED_EX; } HRESULT CTriggerProvider::ValidateParams( IN VARIANT varTrigName, IN VARIANT varTrigAction, IN VARIANT varTrigQuery, IN VARIANT varRUser ) /*++ Routine Description: This routine validates input parameters trigger name, Trigger Query, Trigger Desc, Trigger Action. Arguments: [IN] varTrigName : Trigger Name. [IN] varTrigAction : Trigger Action. [IN] varTrigQuery : Trigger Query. [IN] varRUser : Trigger Query. Return Value: WBEM_S_NO_ERROR if successful. WBEM_E_INVALID_PARAMETER if invalid inputs. --*/ { //local variables HRESULT hRes = 0; IEnumWbemClassObject *pINTEConsumer = NULL; DWORD dwReturned = 0; DWORD dwFlag = 0; TCHAR szTemp[MAX_RES_STRING1]; TCHAR szTemp1[MAX_RES_STRING1]; LPTSTR lpSubStr = NULL; LONG lPos = 0; try { CHString strTemp = L""; if( TRUE == m_MaxTriggers ) { return ( WBEM_E_INVALID_PARAMETER ); } //check if input values are null if ( varTrigName.vt == VT_NULL ) { return ( WBEM_E_INVALID_PARAMETER ); } if ( varTrigAction.vt == VT_NULL ) { return ( WBEM_E_INVALID_PARAMETER ); } if( varTrigQuery.vt == VT_NULL ) { return ( WBEM_E_INVALID_PARAMETER ); } if( varRUser.vt == VT_NULL ) { return ( WBEM_E_INVALID_PARAMETER ); } //validate run as user strTemp = (LPCWSTR) _bstr_t(varRUser.bstrVal); // user name should not be just '\' if ( 0 == strTemp.CompareNoCase( L"\\" ) ) { return WBEM_E_INVALID_PARAMETER; } // user name should not contain invalid characters if ( -1 != strTemp.FindOneOf( L"/[]:|<>+=;,?*" ) ) { return WBEM_E_INVALID_PARAMETER; } lPos = strTemp.Find( L'\\' ); if ( -1 != lPos ) { // '\' character exists in the user name // strip off the user info upto first '\' character // check for one more '\' in the remaining string // if it exists, invalid user strTemp = strTemp.Mid( lPos + 1 ); lPos = strTemp.Find( L'\\' ); if ( -1 != lPos ) { return WBEM_E_INVALID_PARAMETER; } } //validate trigger action strTemp = (LPCWSTR) _bstr_t(varTrigAction.bstrVal); if( strTemp.GetLength() > 262 ) { return ( WBEM_E_INVALID_PARAMETER ); } //validate trigger name strTemp = (LPCWSTR) _bstr_t(varTrigName.bstrVal); dwReturned = strTemp.FindOneOf( L":|<>?*\\/" ); if( dwReturned != -1 ) { return ( WBEM_E_INVALID_PARAMETER ); } // Triggername cannot be more than 196 characters. if( MAX_TRIGGERNAME_LENGTH < strTemp.GetLength() ) { return ( WBEM_E_INVALID_PARAMETER ); } //validate trigger query SecureZeroMemory( szTemp, MAX_RES_STRING1 * sizeof( TCHAR ) ); SecureZeroMemory( szTemp1, MAX_RES_STRING1 * sizeof( TCHAR ) ); strTemp = (LPCWSTR) _bstr_t(varTrigQuery.bstrVal); StringCopy( szTemp, ( LPCWSTR )strTemp, MAX_RES_STRING1 ); lpSubStr = _tcsstr( szTemp, _T( "__instancecreationevent where targetinstance isa \"win32_ntlogevent\"" ) ); if( lpSubStr == NULL ) { return ( WBEM_E_INVALID_PARAMETER ); } //make the SQL staements to query trigger event consumer class to check whether //an instance with the inputted trigger is already exists strTemp = (LPCWSTR) _bstr_t(varTrigName.bstrVal); SecureZeroMemory( szTemp, MAX_RES_STRING1 * sizeof( TCHAR ) ); StringCopy( szTemp, (LPCWSTR)strTemp, MAX_RES_STRING1 ); StringCchPrintf(szTemp1, SIZE_OF_ARRAY( szTemp1 ) , CONSUMER_QUERY, szTemp ); //query triggereventconsumer class hRes = m_pServices->ExecQuery( _bstr_t( QUERY_LANGUAGE ), _bstr_t( szTemp1 ), WBEM_FLAG_RETURN_IMMEDIATELY| WBEM_FLAG_FORWARD_ONLY, NULL, &pINTEConsumer ); //enumerate the result set of execquery for trigger name dwReturned = 1; if ( hRes == WBEM_S_NO_ERROR ) { while ( ( dwReturned == 1 ) && ( dwFlag == 0 ) ) { IWbemClassObject *pINTCons = NULL; // Enumerate through the resultset. hRes = pINTEConsumer->Next( WBEM_INFINITE, 1, // return just one service &pINTCons, // pointer to service &dwReturned ); // number obtained: one or zero if ( SUCCEEDED( hRes ) && ( dwReturned == 1 ) ) { SAFERELEASE( pINTCons ); dwFlag = 1; } // If Service Succeeded } SAFERELEASE( pINTEConsumer ); } if( dwFlag == 1 ) { return ERROR_TRIGNAME_ALREADY_EXIST_EX; } else { return WBEM_S_NO_ERROR; } } catch(_com_error& e) { SAFERELEASE( pINTEConsumer ); return e.Error(); } catch( CHeap_Exception ) { SAFERELEASE( pINTEConsumer ); return E_OUTOFMEMORY; } } HRESULT CTriggerProvider::SetUserContext( IN VARIANT varRUser, IN VARIANT varRPwd, IN VARIANT varTAction, IN CHString &szscheduler ) /*++ Routine Description: This routine creates task scheduler. Arguments: [IN] varRUser : User name. [IN] varRPwd : Password. [IN] varTAction : TriggerAction. [IN] szscheduler : Task scheduler name. Return Value: Returns HRESULT value. --*/ { HRESULT hRes = 0; ITaskScheduler *pITaskScheduler = NULL; ITaskTrigger *pITaskTrig = NULL; ITask *pITask = NULL; IPersistFile *pIPF = NULL; try { CHString strTemp = L""; CHString strTemp1 = L""; SYSTEMTIME systime = {0,0,0,0,0,0,0,0}; WORD wTrigNumber = 0; WCHAR wszCommand[ MAX_STRING_LENGTH ] = L""; WCHAR wszApplName[ MAX_STRING_LENGTH ] = L""; WCHAR wszParams[ MAX_STRING_LENGTH ] = L""; WORD wStartDay = 0; WORD wStartMonth = 0; WORD wStartYear = 0; WORD wStartHour = 0; WORD wStartMin = 0; TASK_TRIGGER TaskTrig; SecureZeroMemory( &TaskTrig, sizeof( TASK_TRIGGER )); TaskTrig.cbTriggerSize = sizeof(TASK_TRIGGER); TaskTrig.Reserved1 = 0; // reserved field and must be set to 0. TaskTrig.Reserved2 = 0; // reserved field and must be set to 0. strTemp = (LPCWSTR) _bstr_t(varTAction.bstrVal); StringCopy( wszCommand, (LPCWSTR) strTemp, SIZE_OF_ARRAY( wszCommand ) ); hRes = GetTaskScheduler( &pITaskScheduler ); if ( FAILED( hRes ) ) { SAFERELEASE( pITaskScheduler ); return hRes; } hRes = pITaskScheduler->SetTargetComputer( NULL ); if( FAILED( hRes ) ) { SAFERELEASE( pITaskScheduler ); return hRes; } hRes = pITaskScheduler->NewWorkItem( szscheduler, CLSID_CTask, IID_ITask, ( IUnknown** )&pITask ); SAFERELEASE( pITaskScheduler ); if( FAILED( hRes ) ) { return hRes; } hRes = pITask->QueryInterface( IID_IPersistFile, ( void ** ) &pIPF ); if ( FAILED( hRes ) ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); return hRes; } BOOL bRet = ProcessFilePath( wszCommand, wszApplName, wszParams ); if( bRet == FALSE ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); return WBEM_E_INVALID_PARAMETER; } if( FindOneOf2( wszApplName, L"|<>?*/", TRUE, 0 ) != -1 ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); return WBEM_E_INVALID_PARAMETER; } hRes = pITask->SetApplicationName( wszApplName ); if ( FAILED( hRes ) ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); return hRes; } wchar_t* wcszStartIn = wcsrchr( wszApplName, _T('\\') ); if( wcszStartIn != NULL ) { *( wcszStartIn ) = _T( '\0' ); } hRes = pITask->SetWorkingDirectory( wszApplName ); if ( FAILED( hRes ) ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); return hRes; } hRes = pITask->SetParameters( wszParams ); if ( FAILED( hRes ) ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); return hRes; } DWORD dwMaxRunTimeMS = INFINITE; hRes = pITask->SetMaxRunTime(dwMaxRunTimeMS); if ( FAILED( hRes ) ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); return hRes; } strTemp = (LPCWSTR)_bstr_t(varRUser.bstrVal); if( strTemp.CompareNoCase(L"system") == 0 ) { hRes = pITask->SetAccountInformation(L"",NULL); } else if( strTemp.CompareNoCase(L"NT AUTHORITY\\SYSTEM") == 0 ) { hRes = pITask->SetAccountInformation(L"",NULL); } else if( strTemp.CompareNoCase(L"") == 0 ) { hRes = pITask->SetAccountInformation(L"",NULL); } else { strTemp1 = (LPCWSTR)_bstr_t(varRPwd.bstrVal); hRes = pITask->SetAccountInformation( ( LPCWSTR ) strTemp, ( LPCWSTR )strTemp1 ); } if ( FAILED( hRes ) ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); return hRes; } GetLocalTime(&systime); wStartDay = systime.wDay; wStartMonth = systime.wMonth; wStartYear = systime.wYear - 1; GetLocalTime(&systime); wStartHour = systime.wHour; wStartMin = systime.wMinute; hRes = pITask->CreateTrigger( &wTrigNumber, &pITaskTrig ); if ( FAILED( hRes ) ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); SAFERELEASE( pITaskTrig ); return hRes; } TaskTrig.TriggerType = TASK_TIME_TRIGGER_ONCE; TaskTrig.wStartHour = wStartHour; TaskTrig.wStartMinute = wStartMin; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; hRes = pITaskTrig->SetTrigger( &TaskTrig ); if ( FAILED( hRes ) ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); SAFERELEASE( pITaskTrig ); return hRes; } hRes = pIPF->Save( NULL,TRUE ); if ( FAILED( hRes ) ) { if ( ( 0x80041315 != hRes ) && ( 0x800706B5 != hRes ) ) { hRes = ERROR_INVALID_USER_EX; } } SAFERELEASE( pIPF ); SAFERELEASE( pITask ); SAFERELEASE( pITaskTrig ); } catch(_com_error& e) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); SAFERELEASE( pITaskTrig ); SAFERELEASE( pITaskScheduler ); return e.Error(); } catch( CHeap_Exception ) { SAFERELEASE( pIPF ); SAFERELEASE( pITask ); SAFERELEASE( pITaskTrig ); SAFERELEASE( pITaskScheduler ); return E_OUTOFMEMORY; } return hRes; } HRESULT CTriggerProvider::DeleteTaskScheduler( IN CHString strTScheduler ) /*++ Routine Description: This routine deletes task scheduler. Arguments: [IN] szTScheduler : Task Scheduler name. Return Value: Returns HRESULT value. --*/ { HRESULT hRes = 0; ITaskScheduler *pITaskScheduler = NULL; IEnumWorkItems *pIEnum = NULL; ITask *pITask = NULL; LPWSTR *lpwszNames = NULL; DWORD dwFetchedTasks = 0; DWORD dwTaskIndex = 0; TCHAR szActualTask[MAX_RES_STRING1] = NULL_STRING; try { hRes = GetTaskScheduler( &pITaskScheduler ); if ( FAILED( hRes ) ) { SAFERELEASE( pITaskScheduler ); return hRes; } hRes = pITaskScheduler->SetTargetComputer( NULL ); if( FAILED( hRes ) ) { SAFERELEASE( pITaskScheduler ); return hRes; } // Enumerate the Work Items hRes = pITaskScheduler->Enum( &pIEnum ); if( FAILED( hRes ) ) { SAFERELEASE( pITaskScheduler ); SAFERELEASE( pIEnum ); return hRes; } while ( SUCCEEDED( pIEnum->Next( 1, &lpwszNames, &dwFetchedTasks ) ) && (dwFetchedTasks != 0)) { dwTaskIndex = dwFetchedTasks-1; // Get the TaskName. StringCopy( szActualTask, lpwszNames[ --dwFetchedTasks ], SIZE_OF_ARRAY( szActualTask ) ); // Parse the TaskName to remove the .job extension. szActualTask[StringLength(szActualTask, 0 ) - StringLength( JOB, 0 ) ] = NULL_CHAR; StrTrim( szActualTask, TRIM_SPACES ); if( StringCompare( szActualTask, strTScheduler, TRUE, 0 ) == 0 ) { hRes = pITaskScheduler->Activate(lpwszNames[dwTaskIndex],IID_ITask, (IUnknown**) &pITask); if( FAILED( hRes ) ) { CoTaskMemFree( lpwszNames[ dwFetchedTasks ] ); SAFERELEASE( pIEnum ); SAFERELEASE( pITaskScheduler ); if ( 0x80070005 == hRes || 0x8007000D == hRes || SCHED_E_UNKNOWN_OBJECT_VERSION == hRes || E_INVALIDARG == hRes ) { return ERROR_TRIGGER_NOT_DELETED_EX; } else { return hRes; } } hRes = pITaskScheduler->Delete( szActualTask ); CoTaskMemFree( lpwszNames[ dwFetchedTasks ] ); SAFERELEASE( pIEnum ); SAFERELEASE( pITask ); SAFERELEASE( pITaskScheduler ); return hRes; } CoTaskMemFree( lpwszNames[ dwFetchedTasks ] ); } } catch(_com_error& e) { SAFERELEASE( pITaskScheduler ); SAFERELEASE( pIEnum ); SAFERELEASE( pITask ); return e.Error(); } SAFERELEASE( pITaskScheduler ); return ERROR_TRIGGER_CORRUPTED_EX; } HRESULT CTriggerProvider::GetTaskScheduler( OUT ITaskScheduler **ppITaskScheduler ) /*++ Routine Description: This routine gets task scheduler interface. Arguments: [OUT] pITaskScheduler - Pointer to ITaskScheduler object. Return Value: Returns HRESULT. --*/ { HRESULT hRes = S_OK; hRes = CoCreateInstance( CLSID_CTaskScheduler, NULL, CLSCTX_ALL, IID_ITaskScheduler,(LPVOID*) ppITaskScheduler ); if( FAILED(hRes)) { return hRes; } return hRes; } VOID CTriggerProvider::GetUniqueTScheduler( OUT CHString& szScheduler, IN DWORD dwTrigID, IN VARIANT varTrigName ) /*++ Routine Description: This routine generates unique task scheduler name. Arguments: [OUT] szScheduler : Unique task scheduler name. [IN] dwTrigID : Trigger id. [IN] varTrigName : Trigger name. Return Value: none. --*/ { DWORD dwTickCount = 0; TCHAR szTaskName[ MAX_RES_STRING1 ] = NULL_STRING; CHString strTemp = L""; strTemp = (LPCWSTR)_bstr_t(varTrigName.bstrVal); dwTickCount = GetTickCount(); StringCchPrintf( szTaskName, SIZE_OF_ARRAY( szTaskName ), UNIQUE_TASK_NAME, ( LPCWSTR )strTemp, dwTrigID, dwTickCount ); szScheduler = szTaskName; } STDMETHODIMP CTriggerProvider::FindConsumer( IN IWbemClassObject* pLogicalConsumer, OUT IWbemUnboundObjectSink** ppConsumer ) /*++ Routine Description: When Windows Management needs to deliver events to a particular logical consumer, it will call the IWbemEventConsumerProvider::FindConsumer method so that the consumer provider can locate the associated consumer event sink. Arguments: [IN] pLogicalConsumer : Pointer to the logical consumer object to which the event objects are to be delivered. [OUT] ppConsumer : Returns an event object sink to Windows Management. Windows Management calls AddRef for this pointer and deliver the events associated with the logical consumer to this sink. Return Value: returns an HRESULT object that indicates the status of the method call. --*/ { // create the logical consumer. CTriggerConsumer* pSink = new CTriggerConsumer(); // return it's "sink" interface. return pSink->QueryInterface( IID_IWbemUnboundObjectSink, ( LPVOID* ) ppConsumer ); }