/****************************************************************************** Copyright(c) Microsoft Corporation Module Name: change.cpp Abstract: This module changes the parameters of task(s) present in the system Author: Venu Gopal Choudary 01-Mar-2001 Revision History: Venu Gopal Choudary 01-Mar-2001 : Created it ******************************************************************************/ //common header files needed for this file #include "pch.h" #include "CommonHeaderFiles.h" // Function declaration for the Usage function. DWORD DisplayChangeUsage(); BOOL GetTheUserName( LPWSTR pszUserName, DWORD dwMaxUserNameSize ); /***************************************************************************** Routine Description: This routine Changes the paraemters of a specified scheduled task(s) Arguments: [ in ] argc : Number of command line arguments [ in ] argv : Array containing command line arguments Return Value : A DWORD value indicating EXIT_SUCCESS on success else EXIT_FAILURE on failure *****************************************************************************/ DWORD ChangeScheduledTaskParams( IN DWORD argc, IN LPCTSTR argv[] ) { // Variables used to find whether Change option, Usage option // are specified or not //BOOL bChange = FALSE; //BOOL bUsage = FALSE; // Set the TaskSchduler object as NULL ITaskScheduler *pITaskScheduler = NULL; // Return value HRESULT hr = S_OK; // Declarations related to Task name LPWSTR wszUserName = NULL; LPWSTR wszPassword = NULL; WCHAR wszApplName[_MAX_FNAME] ; // Dynamic Array contaning array of jobs TARRAY arrJobs = NULL; //buffer for displaying error message WCHAR szMessage[ 2 * MAX_JOB_LEN ] = L"\0"; BOOL bUserName = TRUE; BOOL bPassWord = TRUE; BOOL bSystemStatus = FALSE; //BOOL bNeedPassword = FALSE; BOOL bResult = FALSE; BOOL bCloseConnection = TRUE; DWORD dwPolicy = 0; TCMDPARSER2 cmdChangeOptions[MAX_CHANGE_OPTIONS]; //BOOL bReturn = FALSE; SecureZeroMemory ( wszApplName, SIZE_OF_ARRAY(wszApplName)); // declarations of structures TCHANGESUBOPTS tchgsubops; TCHANGEOPVALS tchgoptvals; //Initialize structures to neutral values. //SecureZeroMemory( &cmdChangeOptions, sizeof( TCMDPARSER2 ) * MAX_CHANGE_OPTIONS); SecureZeroMemory( &tchgsubops, sizeof( TCHANGESUBOPTS ) ); SecureZeroMemory( &tchgoptvals, sizeof( TCHANGEOPVALS ) ); BOOL bReturn = FALSE; // /change sub-options const WCHAR szChangeOpt[] = L"change"; const WCHAR szChangeHelpOpt[] = L"?"; const WCHAR szChangeServerOpt[] = L"s"; const WCHAR szChangeUserOpt[] = L"u"; const WCHAR szChangePwdOpt[] = L"p"; const WCHAR szChangeRunAsUserOpt[] = L"ru"; const WCHAR szChangeRunAsPwdOpt[] = L"rp"; const WCHAR szChangeTaskNameOpt[] = L"tn"; const WCHAR szChangeTaskRunOpt[] = L"tr"; const WCHAR szChangeStartTimeOpt[] = L"st"; const WCHAR szChangeEndTimeOpt[] = L"et"; const WCHAR szChangeStartDateOpt[] = L"sd"; const WCHAR szChangeEndDateOpt[] = L"ed"; const WCHAR szChangeKillAtDurOpt[] = L"k"; const WCHAR szChangeDurationOpt[] = L"du"; const WCHAR szChangeInteractiveOpt[] = L"it"; const WCHAR szChangeStatusOn[] = L"enable"; const WCHAR szChangeStatusOff[] = L"disable"; const WCHAR szChangeDelIfNotSchedOpt[] = L"z"; const WCHAR szChangeRepeatIntervalOpt[] = L"ri"; // // fill the commandline parser // // set all the fields to 0 SecureZeroMemory( cmdChangeOptions, sizeof( TCMDPARSER2 ) * MAX_CHANGE_OPTIONS ); // /change option StringCopyA( cmdChangeOptions[ OI_CHANGE_OPTION ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_OPTION ].dwType = CP_TYPE_BOOLEAN; cmdChangeOptions[ OI_CHANGE_OPTION ].pwszOptions = szChangeOpt; cmdChangeOptions[ OI_CHANGE_OPTION ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_OPTION ].dwFlags = 0; cmdChangeOptions[ OI_CHANGE_OPTION ].pValue = &tchgsubops.bChange; // /? option StringCopyA( cmdChangeOptions[ OI_CHANGE_USAGE ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_USAGE ].dwType = CP_TYPE_BOOLEAN; cmdChangeOptions[ OI_CHANGE_USAGE ].pwszOptions = szChangeHelpOpt; cmdChangeOptions[ OI_CHANGE_USAGE ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_USAGE ].dwFlags = CP2_USAGE; cmdChangeOptions[ OI_CHANGE_USAGE ].pValue = &tchgsubops.bUsage; // /s option StringCopyA( cmdChangeOptions[ OI_CHANGE_SERVER ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_SERVER ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_SERVER ].pwszOptions = szChangeServerOpt; cmdChangeOptions[ OI_CHANGE_SERVER ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_SERVER ].dwFlags = CP2_ALLOCMEMORY| CP2_VALUE_TRIMINPUT|CP2_VALUE_NONULL ; // /u option StringCopyA( cmdChangeOptions[ OI_CHANGE_USERNAME ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_USERNAME ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_USERNAME ].pwszOptions = szChangeUserOpt; cmdChangeOptions[ OI_CHANGE_USERNAME ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_USERNAME ].dwFlags = CP2_ALLOCMEMORY | CP2_VALUE_TRIMINPUT|CP2_VALUE_NONULL ; // /p option StringCopyA( cmdChangeOptions[ OI_CHANGE_PASSWORD ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_PASSWORD ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_PASSWORD ].pwszOptions = szChangePwdOpt; cmdChangeOptions[ OI_CHANGE_PASSWORD ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_PASSWORD ].dwActuals = 0; cmdChangeOptions[ OI_CHANGE_PASSWORD ].dwFlags = CP2_ALLOCMEMORY | CP2_VALUE_OPTIONAL ; // /ru option StringCopyA( cmdChangeOptions[ OI_CHANGE_RUNASUSER ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_RUNASUSER ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_RUNASUSER ].pwszOptions = szChangeRunAsUserOpt; cmdChangeOptions[ OI_CHANGE_RUNASUSER ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_RUNASUSER ].dwFlags = CP2_ALLOCMEMORY| CP2_VALUE_TRIMINPUT; // /rp option StringCopyA( cmdChangeOptions[ OI_CHANGE_RUNASPASSWORD ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_RUNASPASSWORD ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_RUNASPASSWORD ].pwszOptions = szChangeRunAsPwdOpt; cmdChangeOptions[ OI_CHANGE_RUNASPASSWORD ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_RUNASPASSWORD ].dwFlags = CP2_ALLOCMEMORY | CP2_VALUE_OPTIONAL; // /st option StringCopyA( cmdChangeOptions[ OI_CHANGE_STARTTIME ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_STARTTIME ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_STARTTIME ].pwszOptions = szChangeStartTimeOpt; cmdChangeOptions[ OI_CHANGE_STARTTIME ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_STARTTIME ].dwFlags = CP2_VALUE_TRIMINPUT | CP2_VALUE_NONULL; cmdChangeOptions[ OI_CHANGE_STARTTIME ].pValue = tchgsubops.szStartTime; cmdChangeOptions[ OI_CHANGE_STARTTIME ].dwLength = MAX_STRING_LENGTH; // /sd option StringCopyA( cmdChangeOptions[ OI_CHANGE_STARTDATE ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_STARTDATE ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_STARTDATE ].pwszOptions = szChangeStartDateOpt; cmdChangeOptions[ OI_CHANGE_STARTDATE ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_STARTDATE ].dwFlags = CP2_VALUE_TRIMINPUT | CP2_VALUE_NONULL; cmdChangeOptions[ OI_CHANGE_STARTDATE ].pValue = tchgsubops.szStartDate; cmdChangeOptions[ OI_CHANGE_STARTDATE ].dwLength = MAX_STRING_LENGTH; // /ed option StringCopyA( cmdChangeOptions[ OI_CHANGE_ENDDATE ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_ENDDATE ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_ENDDATE ].pwszOptions = szChangeEndDateOpt; cmdChangeOptions[ OI_CHANGE_ENDDATE ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_ENDDATE ].dwFlags = CP2_VALUE_TRIMINPUT | CP2_VALUE_NONULL; cmdChangeOptions[ OI_CHANGE_ENDDATE ].pValue = tchgsubops.szEndDate; cmdChangeOptions[ OI_CHANGE_ENDDATE ].dwLength = MAX_STRING_LENGTH; // /et option StringCopyA( cmdChangeOptions[ OI_CHANGE_ENDTIME ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_ENDTIME ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_ENDTIME ].pwszOptions = szChangeEndTimeOpt; cmdChangeOptions[ OI_CHANGE_ENDTIME ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_ENDTIME ].dwFlags = CP2_VALUE_TRIMINPUT | CP2_VALUE_NONULL; cmdChangeOptions[ OI_CHANGE_ENDTIME ].pValue = &tchgsubops.szEndTime; cmdChangeOptions[ OI_CHANGE_ENDTIME ].dwLength = MAX_STRING_LENGTH; // /k option StringCopyA( cmdChangeOptions[ OI_CHANGE_DUR_END ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_DUR_END ].dwType = CP_TYPE_BOOLEAN ; cmdChangeOptions[ OI_CHANGE_DUR_END ].pwszOptions = szChangeKillAtDurOpt ; cmdChangeOptions[ OI_CHANGE_DUR_END ].dwCount = 1 ; cmdChangeOptions[ OI_CHANGE_DUR_END ].pValue = &tchgsubops.bIsDurEnd; // /du option StringCopyA( cmdChangeOptions[ OI_CHANGE_DURATION ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_DURATION ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_DURATION ].pwszOptions = szChangeDurationOpt; cmdChangeOptions[ OI_CHANGE_DURATION ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_DURATION ].dwFlags = CP2_VALUE_TRIMINPUT | CP2_VALUE_NONULL; cmdChangeOptions[ OI_CHANGE_DURATION ].pValue = tchgsubops.szDuration; cmdChangeOptions[ OI_CHANGE_DURATION ].dwLength = MAX_STRING_LENGTH; // /tn option StringCopyA( cmdChangeOptions[ OI_CHANGE_TASKNAME ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_TASKNAME ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_TASKNAME ].pwszOptions = szChangeTaskNameOpt; cmdChangeOptions[ OI_CHANGE_TASKNAME ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_TASKNAME ].dwFlags = CP2_MANDATORY; cmdChangeOptions[ OI_CHANGE_TASKNAME ].pValue = tchgsubops.szTaskName; cmdChangeOptions[ OI_CHANGE_TASKNAME ].dwLength = MAX_JOB_LEN; // /tr option StringCopyA( cmdChangeOptions[ OI_CHANGE_TASKRUN ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_TASKRUN ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_TASKRUN ].pwszOptions = szChangeTaskRunOpt; cmdChangeOptions[ OI_CHANGE_TASKRUN ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_TASKRUN ].dwFlags = CP2_VALUE_TRIMINPUT|CP2_VALUE_NONULL ; cmdChangeOptions[ OI_CHANGE_TASKRUN ].pValue = tchgsubops.szTaskRun; cmdChangeOptions[ OI_CHANGE_TASKRUN ].dwLength = MAX_TASK_LEN; // /it option StringCopyA( cmdChangeOptions[ OI_CHANGE_IT ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_IT ].dwType = CP_TYPE_BOOLEAN; cmdChangeOptions[ OI_CHANGE_IT ].pwszOptions = szChangeInteractiveOpt; cmdChangeOptions[ OI_CHANGE_IT ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_IT ].dwFlags = 0; cmdChangeOptions[ OI_CHANGE_IT ].pValue = &tchgsubops.bInteractive; // /enable option StringCopyA( cmdChangeOptions[ OI_CHANGE_ENABLE ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_ENABLE ].dwType = CP_TYPE_BOOLEAN; cmdChangeOptions[ OI_CHANGE_ENABLE ].pwszOptions = szChangeStatusOn; cmdChangeOptions[ OI_CHANGE_ENABLE ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_ENABLE ].pValue = &tchgsubops.bEnable; // /disable option StringCopyA( cmdChangeOptions[ OI_CHANGE_DISABLE ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_DISABLE ].dwType = CP_TYPE_BOOLEAN; cmdChangeOptions[ OI_CHANGE_DISABLE ].pwszOptions = szChangeStatusOff; cmdChangeOptions[ OI_CHANGE_DISABLE ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_DISABLE ].pValue = &tchgsubops.bDisable; // /z option StringCopyA( cmdChangeOptions[ OI_CHANGE_DELNOSCHED ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_DELNOSCHED ].dwType = CP_TYPE_BOOLEAN; cmdChangeOptions[ OI_CHANGE_DELNOSCHED ].pwszOptions = szChangeDelIfNotSchedOpt; cmdChangeOptions[ OI_CHANGE_DELNOSCHED ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_DELNOSCHED ].pValue = &tchgsubops.bDelIfNotSched; // /ri option StringCopyA( cmdChangeOptions[ OI_CHANGE_REPEAT_INTERVAL ].szSignature, "PARSER2\0", 8 ); cmdChangeOptions[ OI_CHANGE_REPEAT_INTERVAL ].dwType = CP_TYPE_TEXT; cmdChangeOptions[ OI_CHANGE_REPEAT_INTERVAL ].pwszOptions = szChangeRepeatIntervalOpt; cmdChangeOptions[ OI_CHANGE_REPEAT_INTERVAL ].dwCount = 1; cmdChangeOptions[ OI_CHANGE_REPEAT_INTERVAL ].dwFlags = CP2_VALUE_TRIMINPUT | CP2_VALUE_NONULL; cmdChangeOptions[ OI_CHANGE_REPEAT_INTERVAL ].pValue = tchgsubops.szRepeat; cmdChangeOptions[ OI_CHANGE_REPEAT_INTERVAL ].dwLength = MAX_STRING_LENGTH; //parse command line arguments bReturn = DoParseParam2( argc, argv, 0, SIZE_OF_ARRAY(cmdChangeOptions), cmdChangeOptions, 0); if( FALSE == bReturn) // Invalid commandline { //display an error message ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_INTERNAL ); ReleaseGlobals(); return EXIT_FAILURE; } // get the buffer pointers allocated by command line parser tchgsubops.szServer = (LPWSTR)cmdChangeOptions[ OI_CHANGE_SERVER ].pValue; tchgsubops.szUserName = (LPWSTR)cmdChangeOptions[ OI_CHANGE_USERNAME ].pValue; tchgsubops.szPassword = (LPWSTR)cmdChangeOptions[ OI_CHANGE_PASSWORD ].pValue; tchgsubops.szRunAsUserName = (LPWSTR)cmdChangeOptions[ OI_CHANGE_RUNASUSER ].pValue; tchgsubops.szRunAsPassword = (LPWSTR)cmdChangeOptions[ OI_CHANGE_RUNASPASSWORD ].pValue; // process the options for -change option if( EXIT_FAILURE == ValidateChangeOptions ( argc, cmdChangeOptions, tchgsubops, tchgoptvals ) ) { ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // Displaying change usage if user specified -? with -change option if( tchgsubops.bUsage == TRUE ) { DisplayChangeUsage(); //release memory ReleaseChangeMemory(&tchgsubops); return EXIT_SUCCESS; } // check whether server (-s) and username (-u) only specified along with the command or not if( ( IsLocalSystem( tchgsubops.szServer ) == FALSE ) || ( cmdChangeOptions[OI_CHANGE_USERNAME].dwActuals == 1 ) ) { // Establish the connection on a remote machine bResult = EstablishConnection(tchgsubops.szServer,tchgsubops.szUserName,GetBufferSize(tchgsubops.szUserName)/sizeof(WCHAR),tchgsubops.szPassword,GetBufferSize(tchgsubops.szPassword)/sizeof(WCHAR), tchgoptvals.bNeedPassword ); if (bResult == FALSE) { // displays the appropriate error message ShowLastErrorEx ( stderr, SLE_TYPE_ERROR| SLE_INTERNAL ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE ; } else { // though the connection is successfull, some conflict might have occured switch( GetLastError() ) { case I_NO_CLOSE_CONNECTION: bCloseConnection = FALSE; break; // check for mismatched credentials case E_LOCAL_CREDENTIALS: case ERROR_SESSION_CREDENTIAL_CONFLICT: { bCloseConnection = FALSE; ShowLastErrorEx ( stderr, SLE_TYPE_ERROR| SLE_INTERNAL ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } default : bCloseConnection = TRUE; } } //release memory for password FreeMemory((LPVOID*) &tchgsubops.szPassword); } // Get the task Scheduler object for the system. pITaskScheduler = GetTaskScheduler( tchgsubops.szServer ); // If the Task Scheduler is not defined then give the error message. if ( pITaskScheduler == NULL ) { // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // Validate the Given Task and get as TARRAY in case of taskname arrJobs = ValidateAndGetTasks( pITaskScheduler, tchgsubops.szTaskName); if( arrJobs == NULL ) { StringCchPrintf( szMessage , SIZE_OF_ARRAY(szMessage), GetResString(IDS_TASKNAME_NOTEXIST), _X( tchgsubops.szTaskName )); ShowMessage(stderr, szMessage ); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // check whether the group policy prevented user from changing the // properties of a task or not. if ( FALSE == GetGroupPolicy( tchgsubops.szServer, tchgsubops.szUserName, TS_KEYPOLICY_DENY_PROPERTIES, &dwPolicy ) ) { // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } if ( dwPolicy > 0 ) { ShowMessage ( stdout, GetResString (IDS_PREVENT_CHANGE)); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_SUCCESS; } IPersistFile *pIPF = NULL; ITask *pITask = NULL; ITaskTrigger *pITaskTrig = NULL; WORD wTrigNumber = 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. //sub-variabes WORD wStartDay = 0; WORD wStartMonth = 0; WORD wStartYear = 0; WORD wStartHour = 0; WORD wStartMin = 0; WORD wEndHour = 0; WORD wEndMin = 0; WORD wEndDay = 0; WORD wEndYear = 0; WORD wEndMonth = 0; StringConcat ( tchgsubops.szTaskName, JOB, SIZE_OF_ARRAY(tchgsubops.szTaskName) ); // returns an pITask inteface for szTaskName hr = pITaskScheduler->Activate(tchgsubops.szTaskName,IID_ITask, (IUnknown**) &pITask); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //if the user name is not specifed set the current logged on user settings DWORD dwTaskFlags = 0; BOOL bFlag = FALSE; //WCHAR szBuffer[2 * MAX_STRING_LENGTH] = L"\0"; WCHAR szRunAsUser[MAX_STRING_LENGTH]; WCHAR* szValues[2] = {NULL};//To pass to FormatMessage() API StringCopy ( szRunAsUser, L"", SIZE_OF_ARRAY(szRunAsUser)); if ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) { wszUserName = tchgsubops.szRunAsUserName; bUserName = TRUE; } else { // get the run as user name for a specified scheduled task hr = GetRunAsUser(pITask, szRunAsUser); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } } // System account is not applicable with /IT option if ( (StringLength (szRunAsUser, 0) == 0) && (tchgsubops.bInteractive == TRUE ) && ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 0 )) { ShowMessage ( stderr, GetResString (IDS_IT_NO_SYSTEM) ); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //check whether /TR option is specified or not if( cmdChangeOptions[OI_CHANGE_TASKRUN].dwActuals == 1 ) { // check for .exe substring string in the given task to run string wchar_t wcszParam[MAX_RES_STRING] = L"\0"; DWORD dwProcessCode = 0 ; dwProcessCode = ProcessFilePath(tchgsubops.szTaskRun,wszApplName,wcszParam); if(dwProcessCode == EXIT_FAILURE) { if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // Set command name with ITask::SetApplicationName hr = pITask->SetApplicationName(wszApplName); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //[Working directory = exe pathname - exe name] wchar_t* wcszStartIn = wcsrchr(wszApplName,_T('\\')); if(wcszStartIn != NULL) *( wcszStartIn ) = _T('\0'); // set the working directory of command hr = pITask->SetWorkingDirectory(wszApplName); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // set the command line parameters for the task hr = pITask->SetParameters(wcszParam); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if( pIPF ) { pIPF->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } } // get the flags hr = pITask->GetFlags(&dwTaskFlags); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // set flag to run the task interactively if ( TRUE == tchgsubops.bInteractive ) { dwTaskFlags |= TASK_FLAG_RUN_ONLY_IF_LOGGED_ON; } // remove the .job extension from the taskname if ( ParseTaskName( tchgsubops.szTaskName ) ) { if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // if /enable is specified if ( TRUE == tchgsubops.bEnable ) { // check if task has already been enabled or not if ( !((dwTaskFlags & TASK_FLAG_DISABLED) == TASK_FLAG_DISABLED ) ) { StringCchPrintf ( szMessage, SIZE_OF_ARRAY(szMessage), GetResString(IDS_ALREADY_ENABLED), _X(tchgsubops.szTaskName)); // display message as .. task has already been enabled ShowMessage ( stdout, _X(szMessage)); // if /Enable optional parameter is only specified to change..if the specified // task has already been enabled.. then return with success if( TRUE == tchgoptvals.bFlag ) { if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_SUCCESS; } } else { dwTaskFlags &= ~(TASK_FLAG_DISABLED); } } else if (TRUE == tchgsubops.bDisable ) // if /disable is specified { // check if task is already been disabled or not if ( (dwTaskFlags & TASK_FLAG_DISABLED) == TASK_FLAG_DISABLED ) { StringCchPrintf ( szMessage, SIZE_OF_ARRAY(szMessage), GetResString(IDS_ALREADY_DISABLED), _X(tchgsubops.szTaskName)); // display message as .. task has already been disabled ShowMessage ( stdout, _X(szMessage)); // if /Disable optional parameter is only specified to change..if the specified // task has already been disabled.. then return with success if( TRUE == tchgoptvals.bFlag ) { if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_SUCCESS; } } else { dwTaskFlags |= TASK_FLAG_DISABLED; } } // if /n is specified .. enables the falg to delete the task if not scheduled to // run again... if ( TRUE == tchgsubops.bDelIfNotSched) { dwTaskFlags |= TASK_FLAG_DELETE_WHEN_DONE; } // set the flags hr = pITask->SetFlags(dwTaskFlags); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } if ( bSystemStatus == TRUE ) { //szValues[0] = (WCHAR*) (tchgsubops.szTaskName); StringCchPrintf ( szMessage, SIZE_OF_ARRAY(szMessage), GetResString(IDS_NTAUTH_SYSTEM_CHANGE_INFO), _X(tchgsubops.szTaskName)); ShowMessage ( stdout, _X(szMessage)); } if( (cmdChangeOptions[OI_CHANGE_RUNASPASSWORD].dwActuals == 1) && ( bSystemStatus == TRUE ) && (StringLength( tchgsubops.szRunAsPassword, 0 ) != 0) ) { ShowMessage( stdout, GetResString( IDS_PASSWORD_NOEFFECT ) ); } //get the trigger for the corresponding task hr = pITask->GetTrigger(wTrigNumber, &pITaskTrig); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //Get the current task trigger hr = pITaskTrig->GetTrigger(&TaskTrig); if (hr != S_OK) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //sub-variables DWORD dwRepeat = 0; DWORD dwEndTimeInMin = 0; DWORD dwStartTimeInMin = 0; DWORD dwDuration = 0; DWORD dwModifierVal = 0; LPWSTR pszStopString = NULL; // check whether /SD o /ED is specified for the scheduled type ONETIME if( ( TaskTrig.TriggerType == TASK_TIME_TRIGGER_ONCE) && (( cmdChangeOptions[OI_CHANGE_STARTDATE].dwActuals == 1 ) || ( cmdChangeOptions[OI_CHANGE_ENDDATE].dwActuals == 1 ) ) ) { // display an error message as.. /SD or /ED is not allowed for ONCE ShowMessage(stderr, GetResString(IDS_CHANGE_ONCE_NA)); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //check whether either /Rt or /Et or /Ri or /Du is specified for the existing scheduled types // onstart, onlogon and onstart.. if ( ( ( cmdChangeOptions[OI_CHANGE_REPEAT_INTERVAL].dwActuals == 1) || ( cmdChangeOptions[OI_CHANGE_DURATION].dwActuals == 1) || ( cmdChangeOptions[OI_CHANGE_ENDTIME].dwActuals == 1) || ( cmdChangeOptions[OI_CHANGE_ENDDATE].dwActuals == 1) || ( cmdChangeOptions[OI_CHANGE_STARTTIME].dwActuals == 1) || ( cmdChangeOptions[OI_CHANGE_STARTDATE].dwActuals == 1) || ( cmdChangeOptions[OI_CHANGE_DUR_END].dwActuals == 1) ) && ( (TaskTrig.TriggerType == TASK_EVENT_TRIGGER_ON_IDLE) || (TaskTrig.TriggerType == TASK_EVENT_TRIGGER_AT_SYSTEMSTART ) || ( TaskTrig.TriggerType == TASK_EVENT_TRIGGER_AT_LOGON ) ) ) { ShowMessage (stderr, GetResString (IDS_SCTYPE_NA) ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //If either /DU or /ET is specified and /RI is not specified.. // then set dwRepeat-> actual repetition value if( (cmdChangeOptions[OI_CHANGE_REPEAT_INTERVAL].dwActuals == 0) && ( (cmdChangeOptions[OI_CHANGE_DURATION].dwActuals == 1) || (cmdChangeOptions[OI_CHANGE_ENDTIME].dwActuals == 1) ) ) { if ( 0 != TaskTrig.MinutesInterval ) { dwRepeat = TaskTrig.MinutesInterval; } else { //repetition interval defaults to 10 minutes dwRepeat = 10; } } //If either /DU or /ET is not specified and /RI is specified.. // then set dwDuration-> actual duration value if( ( cmdChangeOptions[OI_CHANGE_DURATION].dwActuals == 0 ) && ( cmdChangeOptions[OI_CHANGE_ENDTIME].dwActuals == 0 ) && (cmdChangeOptions[OI_CHANGE_REPEAT_INTERVAL].dwActuals == 1) ) { if ( 0 != TaskTrig.MinutesDuration ) { dwDuration = TaskTrig.MinutesDuration; } else { //duration defaults to 10 minutes dwDuration = 60; } } if( cmdChangeOptions[OI_CHANGE_REPEAT_INTERVAL].dwActuals == 1) { // get the repetition value dwRepeat = wcstol(tchgsubops.szRepeat, &pszStopString, BASE_TEN); if ((errno == ERANGE) || ((pszStopString != NULL) && (StringLength (pszStopString, 0) != 0) ) || ( (dwRepeat < MIN_REPETITION_INTERVAL ) || ( dwRepeat > MAX_REPETITION_INTERVAL) ) ) { // display an error message as .. invalid value specified for /RT ShowMessage ( stderr, GetResString (IDS_INVALID_RT_VALUE) ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //check whether the specified repetition interval is greater than 9999.. // if so, set the maximum repetition interval as 9999. if ( (dwRepeat > 9999) && ( (dwRepeat % 60) != 0) ) { //display some warning message as.. max value (less than the specified interval) // divisible by 60. ShowMessage ( stderr, GetResString (IDS_WARN_VALUE) ); dwRepeat -= (dwRepeat % 60); } } // if the start time is specified..set the specified values to the current trigger if (cmdChangeOptions[ OI_CHANGE_STARTTIME ].dwActuals == 1) { // get the Start time in terms of hours, minutes and seconds GetTimeFieldEntities(tchgsubops.szStartTime, &wStartHour, &wStartMin ); // set the start time TaskTrig.wStartHour = wStartHour; TaskTrig.wStartMinute = wStartMin; } else { // get the values for start time wStartHour = TaskTrig.wStartHour; wStartMin = TaskTrig.wStartMinute; } //check whether /ET is specified or not if (cmdChangeOptions[OI_CHANGE_ENDTIME].dwActuals == 1) { // get the Start time in terms of hours, minutes and seconds GetTimeFieldEntities(tchgsubops.szEndTime, &wEndHour, &wEndMin ); // calculate start time in minutes dwStartTimeInMin = (DWORD) ( wStartHour * MINUTES_PER_HOUR * SECS_PER_MINUTE + wStartMin * SECS_PER_MINUTE )/ SECS_PER_MINUTE ; // calculate end time in minutes dwEndTimeInMin = (DWORD) ( wEndHour * MINUTES_PER_HOUR * SECS_PER_MINUTE + wEndMin * SECS_PER_MINUTE ) / SECS_PER_MINUTE ; // check whether end time is later than start time if ( dwEndTimeInMin >= dwStartTimeInMin ) { // if the end and start time in the same day.. // get the duration between end and start time (in minutes) dwDuration = dwEndTimeInMin - dwStartTimeInMin ; } else { // if the start and end time not in the same day.. // get the duration between start and end time (in minutes) // and subtract that duration by 1440(max value in minutes).. dwDuration = 1440 - (dwStartTimeInMin - dwEndTimeInMin ) ; } dwModifierVal = TaskTrig.MinutesInterval ; //check whether The duration is greater than the repetition interval or not. if ( dwDuration <= dwModifierVal || dwDuration <= dwRepeat) { ShowMessage ( stderr, GetResString (IDS_INVALID_DURATION1) ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } } else if(cmdChangeOptions[OI_CHANGE_DURATION].dwActuals == 1) { //sub-variables WCHAR tHours[MAX_RES_STRING]; WCHAR tMins[MAX_RES_STRING]; DWORD dwDurationHours = 0; DWORD dwDurationMin = 0; //initialize the variables SecureZeroMemory (tHours, SIZE_OF_ARRAY(tHours)); SecureZeroMemory (tMins, SIZE_OF_ARRAY(tMins)); if ( ( StringLength (tchgsubops.szDuration, 0) != 7 ) || (tchgsubops.szDuration[4] != TIME_SEPARATOR_CHAR) ) { ShowMessage ( stderr, GetResString (IDS_INVALIDDURATION_FORMAT) ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } StringCopy(tHours, wcstok(tchgsubops.szDuration,TIME_SEPARATOR_STR), SIZE_OF_ARRAY(tHours)); // Get the Hours field. if(StringLength(tHours, 0) > 0) { StringCopy(tMins, wcstok(NULL,TIME_SEPARATOR_STR), SIZE_OF_ARRAY(tMins)); // Get the Minutes field. } dwDurationHours = wcstol(tHours, &pszStopString, BASE_TEN); if ((errno == ERANGE) || ((pszStopString != NULL) && (StringLength (pszStopString, 0) != 0) ) ) { ShowMessage ( stderr, GetResString (IDS_INVALID_DU_VALUE) ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } dwDurationHours = dwDurationHours * MINUTES_PER_HOUR; dwDurationMin = wcstol(tMins, &pszStopString, BASE_TEN); if ((errno == ERANGE) || ((pszStopString != NULL) && (StringLength (pszStopString, 0) != 0) ) ) { ShowMessage ( stderr, GetResString (IDS_INVALID_DU_VALUE) ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // sum the hours and minutes into minutes dwDuration = dwDurationHours + dwDurationMin ; dwModifierVal = TaskTrig.MinutesInterval ; //check whether The duration is greater than the repetition interval or not. if ( dwDuration <= dwModifierVal || dwDuration <= dwRepeat) { ShowMessage ( stderr, GetResString (IDS_INVALID_DURATION2) ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } } // set the repetition interval and duration values { // if repetition interval is not 0.. then set actual value of /RI if ( 0 != dwRepeat ) { // set the MinutesInterval TaskTrig.MinutesInterval = dwRepeat; } // if duration is not 0.. set the actual value of /DU if ( 0 != dwDuration ) { // set the duration value TaskTrig.MinutesDuration = dwDuration ; } } //check whether The duration is greater than the repetition interval or not. if ( (0 != dwRepeat) && ( dwDuration <= dwRepeat ) ) { ShowMessage ( stderr, GetResString (IDS_INVALID_DURATION2) ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // if the start date is specified..set the specified values to the current trigger if (cmdChangeOptions[OI_CHANGE_STARTDATE].dwActuals == 1) { // get the Start date in terms of day, month and year GetDateFieldEntities(tchgsubops.szStartDate, &wStartDay, &wStartMonth, &wStartYear); // set the start time TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; } else { // get the esisting start time wStartDay = TaskTrig.wBeginDay ; wStartMonth = TaskTrig.wBeginMonth ; wStartYear = TaskTrig.wBeginYear ; } //check whether /K is specified or not if ( TRUE == tchgsubops.bIsDurEnd ) { // set the flag to terminate the task at the end of lifetime. TaskTrig.rgFlags |= TASK_TRIGGER_FLAG_KILL_AT_DURATION_END ; } // if the start time is specified..set the specified values to the current trigger if (cmdChangeOptions[OI_CHANGE_ENDDATE].dwActuals == 1) { // Now set the end date entities. GetDateFieldEntities(tchgsubops.szEndDate, &wEndDay, &wEndMonth, &wEndYear); // Make end date valid; otherwise the enddate parameter is ignored. TaskTrig.rgFlags |= TASK_TRIGGER_FLAG_HAS_END_DATE; TaskTrig.wEndDay = wEndDay; TaskTrig.wEndMonth = wEndMonth; TaskTrig.wEndYear = wEndYear; } else { // get the esisting end date wEndDay = TaskTrig.wEndDay ; wEndMonth = TaskTrig.wEndMonth ; wEndYear = TaskTrig.wEndYear ; } if ( (0 != wStartYear) && (0 != wEndYear) ) { //check whether end date is earlier than start date or not if( ( wEndYear == wStartYear ) ) { // For same years if the end month is less than start month or for same years and same months // if the endday is less than the startday. if ( ( wEndMonth < wStartMonth ) || ( ( wEndMonth == wStartMonth ) && ( wEndDay < wStartDay ) ) ) { ShowMessage(stderr, GetResString(IDS_ENDATE_INVALID)); return RETVAL_FAIL; } } else if ( wEndYear < wStartYear ) { ShowMessage(stderr, GetResString(IDS_ENDATE_INVALID)); return RETVAL_FAIL; } } // set the task trigger hr = pITaskTrig->SetTrigger(&TaskTrig); if (hr != S_OK) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } ///////////////////////////////////////// //check for user creentials //////////////////////////////////////// // Check whether /ru "" or "System" or "Nt Authority\System" for system account if ( ( ((tchgsubops.bInteractive == TRUE ) && (StringLength (szRunAsUser, 0) == 0)) || (cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) ) && ( (StringLength( tchgsubops.szRunAsUserName, 0) == 0) || ( StringCompare(tchgsubops.szRunAsUserName, NTAUTHORITY_USER, TRUE, 0 ) == 0 ) || (StringCompare(tchgsubops.szRunAsUserName, SYSTEM_USER, TRUE, 0 ) == 0 ) ) ) { bSystemStatus = TRUE; bFlag = TRUE; } else if ( FAILED (hr) ) { bFlag = TRUE; } // flag to check whether run as user name is "NT AUTHORITY\SYSTEM" or not if ( bFlag == FALSE ) { // check for "NT AUTHORITY\SYSTEM" username if( ( ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) && ( StringLength( tchgsubops.szRunAsUserName, 0) == 0 ) ) || ( ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) && ( StringLength( tchgsubops.szRunAsUserName, 0) == 0 ) && ( StringLength(tchgsubops.szRunAsPassword, 0 ) == 0 ) ) || ( ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) && ( StringCompare(tchgsubops.szRunAsUserName, NTAUTHORITY_USER, TRUE, 0 ) == 0 ) && ( StringLength(tchgsubops.szRunAsPassword, 0 ) == 0 )) || ( ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) && ( StringCompare(tchgsubops.szRunAsUserName, NTAUTHORITY_USER, TRUE, 0 ) == 0 ) ) || ( ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) && ( StringCompare(tchgsubops.szRunAsUserName, SYSTEM_USER, TRUE, 0) == 0 ) && ( StringLength(tchgsubops.szRunAsPassword, 0 ) == 0 ) ) || ( ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) && ( StringCompare(tchgsubops.szRunAsUserName, SYSTEM_USER, TRUE, 0 ) == 0 ) ) ) { bSystemStatus = TRUE; } } if ( bSystemStatus == FALSE ) { //check the length of run as user name if ( (StringLength( tchgsubops.szRunAsUserName, 0 ) != 0 )) { wszUserName = tchgsubops.szRunAsUserName; } else if (( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 0 )) { wszUserName = szRunAsUser; bUserName = TRUE; } else { bUserName = FALSE; } //check for the null password if ( ( StringLength( tchgsubops.szRunAsPassword, 0 ) != 0 ) && ( StringCompare ( tchgsubops.szRunAsPassword, ASTERIX, TRUE, 0) != 0 ) ) { wszPassword = tchgsubops.szRunAsPassword; bPassWord = TRUE; } else { // check whether -rp is specified or not if (cmdChangeOptions[OI_CHANGE_RUNASPASSWORD].dwActuals == 1) { if( ( StringCompare( tchgsubops.szRunAsPassword , L"\0", TRUE, 0 ) != 0 ) && ( StringCompare ( tchgsubops.szRunAsPassword, ASTERIX, TRUE, 0) != 0 ) ) { bPassWord = TRUE; } else if ( ( bSystemStatus == FALSE ) && ( StringLength (tchgsubops.szRunAsPassword, 0) == 0 ) ) { ShowMessage (stderr, GetResString(IDS_WARN_EMPTY_PASSWORD)); } else if ( StringCompare ( tchgsubops.szRunAsPassword, ASTERIX, TRUE, 0) == 0 ) { bPassWord = FALSE; } } else if ( bSystemStatus == FALSE ) { bPassWord = FALSE; } } } // check for the status of username and password if( ( bUserName == TRUE ) && ( bPassWord == FALSE ) ) { szValues[0] = (WCHAR*) (wszUserName); ShowMessageEx ( stderr, 1, FALSE, GetResString(IDS_PROMPT_CHGPASSWD), _X(wszUserName)); // Get the password from the command line if (GetPassword( tchgsubops.szRunAsPassword, GetBufferSize(tchgsubops.szRunAsPassword)/sizeof(WCHAR) ) == FALSE ) { // close the connection that was established by the utility if ( bCloseConnection == TRUE ) { CloseConnection( tchgsubops.szServer ); } ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //check for the null password if( StringCompare( tchgsubops.szRunAsPassword , L"\0", TRUE, 0 ) == 0 ) { ShowMessage (stderr, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the password length > 0 wszPassword = tchgsubops.szRunAsPassword; } // check for the status of user name and password else if( ( bUserName == FALSE ) && ( bPassWord == TRUE ) ) { if ( (bFlag == TRUE ) && ( bSystemStatus == FALSE ) ) { ShowMessage(stdout, GetResString(IDS_PROMPT_USERNAME)); if ( GetTheUserName( tchgsubops.szRunAsUserName, GetBufferSize(tchgsubops.szRunAsUserName)/sizeof(WCHAR)) == FALSE ) { ShowMessage(stderr, GetResString( IDS_FAILED_TOGET_USER ) ); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // check for the length of username if( StringLength(tchgsubops.szRunAsUserName, 0) > MAX_RES_STRING ) { ShowMessage(stderr,GetResString(IDS_INVALID_UNAME )); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } if ( (StringLength( tchgsubops.szRunAsUserName, 0) == 0) || ( StringCompare(tchgsubops.szRunAsUserName, NTAUTHORITY_USER, TRUE, 0 ) == 0 ) || (StringCompare(tchgsubops.szRunAsUserName, SYSTEM_USER, TRUE, 0 ) == 0 ) ) { bSystemStatus = TRUE; bFlag = TRUE; } else { // check for the length of run as user name if(StringLength(tchgsubops.szRunAsUserName, 0)) { wszUserName = tchgsubops.szRunAsUserName; } } } else { wszUserName = szRunAsUser; } // check for the length of password > 0 wszPassword = tchgsubops.szRunAsPassword; } // check for the user name and password are not specified else if( ( bUserName == FALSE ) && ( bPassWord == FALSE ) ) { if ( (bFlag == TRUE ) && ( bSystemStatus == FALSE ) ) { ShowMessage(stdout, GetResString(IDS_PROMPT_USERNAME)); if ( GetTheUserName( tchgsubops.szRunAsUserName, GetBufferSize(tchgsubops.szRunAsUserName)/sizeof(WCHAR) ) == FALSE ) { ShowMessage(stderr, GetResString( IDS_FAILED_TOGET_USER ) ); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // check for the length of username if( StringLength(tchgsubops.szRunAsUserName, 0) > MAX_RES_STRING ) { ShowMessage(stderr,GetResString(IDS_INVALID_UNAME )); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } if ( (StringLength( tchgsubops.szRunAsUserName, 0) == 0) || ( StringCompare(tchgsubops.szRunAsUserName, NTAUTHORITY_USER, TRUE, 0 ) == 0 ) || (StringCompare(tchgsubops.szRunAsUserName, SYSTEM_USER, TRUE, 0 ) == 0 ) ) { bSystemStatus = TRUE; bFlag = TRUE; } else { if(StringLength(tchgsubops.szRunAsUserName, 0)) { wszUserName = tchgsubops.szRunAsUserName; } } } else { wszUserName = szRunAsUser; } if ( StringLength ( wszUserName, 0 ) != 0 ) { szValues[0] = (WCHAR*) (wszUserName); ShowMessageEx ( stderr, 1, FALSE, GetResString(IDS_PROMPT_CHGPASSWD), _X(wszUserName)); // Get the run as user password from the command line if ( GetPassword( tchgsubops.szRunAsPassword, GetBufferSize(tchgsubops.szRunAsPassword)/sizeof(WCHAR) ) == FALSE ) { // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //check for the null password if( StringCompare( tchgsubops.szRunAsPassword , L"\0", TRUE, 0 ) == 0 ) { ShowMessage (stderr, GetResString(IDS_WARN_EMPTY_PASSWORD)); } wszPassword = tchgsubops.szRunAsPassword; } } //check for null password if ( NULL == wszPassword ) { wszPassword = L"\0"; } // Return a pointer to a specified interface on an object hr = pITask->QueryInterface(IID_IPersistFile, (void **) &pIPF); if (FAILED(hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //set account information.. if( bSystemStatus == TRUE ) { // Change the account information to "NT AUTHORITY\SYSTEM" user hr = pITask->SetAccountInformation(L"",NULL); if ( FAILED(hr) ) { ShowMessage(stderr, GetResString(IDS_NTAUTH_SYSTEM_ERROR)); if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } } else { // set the account information with the user name and password hr = pITask->SetAccountInformation(wszUserName,wszPassword); } if ((FAILED(hr)) && (hr != SCHED_E_NO_SECURITY_SERVICES)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } //////////////////////////////////////// /// Save all the parameters //////////////////////////////////////// // save the copy of an object hr = pIPF->Save(NULL,TRUE); if( E_FAIL == hr ) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } if (FAILED (hr)) { SetLastError ((DWORD) hr); ShowLastErrorEx ( stderr, SLE_TYPE_ERROR | SLE_SYSTEM ); if(pIPF) pIPF->Release(); if(pITask) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } else { // to display a success message //szValues[0] = (WCHAR*) (tchgsubops.szTaskName); StringCchPrintf ( szMessage, SIZE_OF_ARRAY(szMessage), GetResString(IDS_CHANGE_SUCCESSFUL), _X(tchgsubops.szTaskName)); ShowMessage ( stdout, _X(szMessage)); } if( pIPF ) pIPF->Release(); if( pITask ) pITask->Release(); if( pITaskTrig ) pITaskTrig->Release(); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tchgsubops.szServer ); Cleanup(pITaskScheduler); ReleaseChangeMemory(&tchgsubops); return EXIT_SUCCESS; } /****************************************************************************** Routine Description: This routine displays the create option usage Arguments: None Return Value : DWORD ******************************************************************************/ DWORD DisplayChangeUsage() { WCHAR szTmpBuffer[ 2 * MAX_STRING_LENGTH]; WCHAR szBuffer[ 2 * MAX_STRING_LENGTH]; WCHAR szFormat[MAX_DATE_STR_LEN]; // initialize to zero SecureZeroMemory ( szTmpBuffer, SIZE_OF_ARRAY(szTmpBuffer)); SecureZeroMemory ( szBuffer, SIZE_OF_ARRAY(szBuffer)); SecureZeroMemory ( szFormat, SIZE_OF_ARRAY(szFormat)); // get the date format if ( GetDateFormatString( szFormat) ) { return EXIT_FAILURE; } // Displaying Create usage for( DWORD dw = IDS_CHANGE_HLP1; dw <= IDS_CHANGE_HLP38; dw++ ) { switch (dw) { case IDS_CHANGE_HLP30: StringCchPrintf ( szTmpBuffer, SIZE_OF_ARRAY(szTmpBuffer), GetResString(IDS_CHANGE_HLP30), _X(szFormat) ); ShowMessage ( stdout, _X(szTmpBuffer) ); dw = IDS_CHANGE_HLP30; break; case IDS_CHANGE_HLP31: StringCchPrintf ( szTmpBuffer, SIZE_OF_ARRAY(szTmpBuffer), GetResString(IDS_CHANGE_HLP31), _X(szFormat) ); ShowMessage ( stdout, _X(szTmpBuffer) ); dw = IDS_CHANGE_HLP31; break; default : ShowMessage(stdout, GetResString(dw)); break; } } return EXIT_SUCCESS; } // *************************************************************************** // Routine Description: // // Takes the user name from the keyboard.While entering the user name // it displays the user name as it is. // // Arguments: // // [in] pszUserName -- String to store user name // [in] dwMaxUserNameSize -- Maximun size of the user name. // // Return Value: // // BOOL --If this function succeds returns TRUE otherwise returns FALSE. // // *************************************************************************** BOOL GetTheUserName( IN LPWSTR pszUserName, IN DWORD dwMaxUserNameSize ) { // local variables WCHAR ch; DWORD dwIndex = 0; DWORD dwCharsRead = 0; DWORD dwCharsWritten = 0; DWORD dwPrevConsoleMode = 0; HANDLE hInputConsole = NULL; WCHAR szBuffer[ 10 ] = L"\0"; BOOL bFlag = TRUE; // check the input value if ( pszUserName == NULL ) { SetLastError( ERROR_INVALID_PARAMETER ); SaveLastError(); return FALSE; } // Get the handle for the standard input hInputConsole = GetStdHandle( STD_INPUT_HANDLE ); if ( hInputConsole == NULL ) { // could not get the handle so return failure return FALSE; } // Get the current input mode of the input buffer GetConsoleMode( hInputConsole, &dwPrevConsoleMode ); // Set the mode such that the control keys are processed by the system if ( SetConsoleMode( hInputConsole, ENABLE_PROCESSED_INPUT ) == 0 ) { // could not set the mode, return failure return FALSE; } // Read the characters until a carriage return is hit do { if ( ReadConsole( hInputConsole, &ch, 1, &dwCharsRead, NULL ) == 0 ) { // Set the original console settings SetConsoleMode( hInputConsole, dwPrevConsoleMode ); // return failure return FALSE; } // Check for carraige return if ( ch == CARRIAGE_RETURN ) { ShowMessage(stdout, _T("\n")); bFlag = FALSE; // break from the loop break; } // Check id back space is hit if ( ch == BACK_SPACE ) { if ( dwIndex != 0 ) { // move the cursor one character back StringCchPrintf( szBuffer, SIZE_OF_ARRAY(szBuffer), _T( "%c" ), BACK_SPACE ); WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), szBuffer, 1, &dwCharsWritten, NULL ); // replace the existing character with space StringCchPrintf( szBuffer, SIZE_OF_ARRAY(szBuffer), _T( "%c" ), BLANK_CHAR ); WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), szBuffer, 1, &dwCharsWritten, NULL ); // now set the cursor at back position StringCchPrintf( szBuffer, SIZE_OF_ARRAY(szBuffer), _T( "%c" ), BACK_SPACE ); WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), szBuffer, 1, &dwCharsWritten, NULL ); // decrement the index dwIndex--; } // process the next character continue; } // if the max user name length has been reached then sound a beep if ( dwIndex == ( dwMaxUserNameSize - 1 ) ) { WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), BEEP_SOUND, 1, &dwCharsRead, NULL ); } else { // store the input character *( pszUserName + dwIndex ) = ch; // display asterix onto the console WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), ( pszUserName + dwIndex ) , 1, &dwCharsWritten, NULL ); dwIndex++; } } while (TRUE == bFlag); // Add the NULL terminator *( pszUserName + dwIndex ) = L'\0'; // Return success return TRUE; } /****************************************************************************** Routine Description: This routine parses and validates the options specified by the user & determines the type of a scheduled task Arguments: [ in ] argc : The count of arguments given by the user. [ out ] tchgsubops : Structure containing Scheduled task's properties. [ out ] tchgoptvals : Structure containing optional properties to set for a scheduledtask . [ out ] pdwRetScheType : pointer to the type of a schedule task [Daily,once,weekly etc]. [ out ] pbUserStatus : pointer to check whether the -ru is given in the command line or not. Return Value : A DWORD value indicating RETVAL_SUCCESS on success else EXIT_FAILURE on failure ******************************************************************************/ DWORD ValidateChangeOptions( IN DWORD argc, OUT TCMDPARSER2 cmdChangeOptions[], IN OUT TCHANGESUBOPTS &tchgsubops, IN OUT TCHANGEOPVALS &tchgoptvals ) { DWORD dwScheduleType = 0; // If -ru is not specified allocate the memory if ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 0 ) { // password if ( tchgsubops.szRunAsUserName == NULL ) { tchgsubops.szRunAsUserName = (LPWSTR)AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) ); if ( tchgsubops.szRunAsUserName == NULL ) { SaveLastError(); return EXIT_FAILURE; } } } // If -rp is not specified allocate the memory if ( cmdChangeOptions[OI_CHANGE_RUNASPASSWORD].dwActuals == 0 ) { // password if ( tchgsubops.szRunAsPassword == NULL ) { tchgsubops.szRunAsPassword = (LPWSTR)AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) ); if ( tchgsubops.szRunAsPassword == NULL ) { SaveLastError(); return EXIT_FAILURE; } } } else { if ( cmdChangeOptions[ OI_CHANGE_RUNASPASSWORD ].pValue == NULL ) { tchgsubops.szRunAsPassword = (LPWSTR)AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) ); if ( NULL == tchgsubops.szRunAsPassword) { SaveLastError(); return EXIT_FAILURE; } StringCopy( tchgsubops.szRunAsPassword, L"*", GetBufferSize(tchgsubops.szRunAsPassword)/sizeof(WCHAR)); } } //check for /? (usage) if ( tchgsubops.bUsage == TRUE ) { if (argc > 3) { ShowMessage ( stderr, GetResString (IDS_ERROR_CHANGEPARAM) ); return EXIT_FAILURE; } else if ( 3 == argc ) { return EXIT_SUCCESS; } } //check whether any optional parameters are specified or not. if( ( 0 == cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_RUNASPASSWORD].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_TASKRUN].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_STARTTIME].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_STARTDATE].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_ENDDATE].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_IT].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_ENDTIME].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_DUR_END].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_DURATION].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_DELNOSCHED].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_REPEAT_INTERVAL].dwActuals ) ) { if ( ( 0 == cmdChangeOptions[OI_CHANGE_ENABLE].dwActuals ) && ( 0 == cmdChangeOptions[OI_CHANGE_DISABLE].dwActuals ) ) { ShowMessage(stderr,GetResString(IDS_NO_CHANGE_OPTIONS)); return EXIT_FAILURE; } else { tchgoptvals.bFlag = TRUE; } } // check whether -u or -ru options specified respectively with -p or -rp options or not if ( cmdChangeOptions[ OI_CHANGE_USERNAME ].dwActuals == 0 && cmdChangeOptions[ OI_CHANGE_PASSWORD ].dwActuals == 1 ) { // invalid syntax ShowMessage(stderr, GetResString(IDS_CHPASSWORD_BUT_NOUSERNAME)); return EXIT_FAILURE; // indicate failure } // check for invalid user name if( ( cmdChangeOptions[OI_CHANGE_SERVER].dwActuals == 0 ) && ( cmdChangeOptions[OI_CHANGE_USERNAME].dwActuals == 1 ) ) { ShowMessage(stderr, GetResString(IDS_CHANGE_USER_BUT_NOMACHINE)); return EXIT_FAILURE; } // check for /IT switch is not applicable with "NT AUTHORITY\SYSTEM" account if ( ( cmdChangeOptions[OI_CHANGE_RUNASUSER].dwActuals == 1 ) && ( ( StringLength ( tchgsubops.szRunAsUserName, 0 ) == 0 ) || ( StringCompare( tchgsubops.szRunAsUserName, NTAUTHORITY_USER, TRUE, 0 ) == 0 ) || ( StringCompare( tchgsubops.szRunAsUserName, SYSTEM_USER, TRUE, 0 ) == 0 ) ) && ( TRUE == tchgsubops.bInteractive ) ) { ShowMessage ( stderr, GetResString (IDS_IT_SWITCH_NA) ); return EXIT_FAILURE; } // If -rp is not specified allocate the memory if ( cmdChangeOptions[OI_CHANGE_RUNASPASSWORD].dwActuals == 0 ) { // password if ( tchgsubops.szRunAsPassword == NULL ) { tchgsubops.szRunAsPassword = (LPWSTR)AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) ); if ( tchgsubops.szRunAsPassword == NULL ) { SaveLastError(); return EXIT_FAILURE; } } } // //check for INVALID SYNTAX // // check for invalid user name if( ( cmdChangeOptions[OI_CHANGE_SERVER].dwActuals == 0 ) && ( cmdChangeOptions[OI_CHANGE_USERNAME].dwActuals == 1 ) ) { ShowMessage(stderr, GetResString(IDS_CHANGE_USER_BUT_NOMACHINE)); //release memory ReleaseChangeMemory(&tchgsubops); return EXIT_FAILURE; } // check whether /ET and /DU specified.. if( ( cmdChangeOptions[OI_CHANGE_DURATION].dwActuals == 1 ) && ( cmdChangeOptions[OI_CHANGE_ENDTIME].dwActuals == 1 ) ) { // display an error message as.. /ET and /DU are mutual exclusive ShowMessage(stderr, GetResString(IDS_DURATION_NOT_ENDTIME)); return EXIT_FAILURE; } if ( ( cmdChangeOptions[OI_CHANGE_DUR_END].dwActuals == 1 ) && ( cmdChangeOptions[OI_CHANGE_DURATION].dwActuals == 0 ) && ( cmdChangeOptions[OI_CHANGE_ENDTIME].dwActuals == 0 ) ) { ShowMessage(stderr, GetResString(IDS_NO_CHANGE_K_OR_RT)); return EXIT_FAILURE; } // check whether /enable and /disable options are specified.. if ( ( TRUE == tchgsubops.bEnable )&& (TRUE == tchgsubops.bDisable ) ) { // display an error message as.. /Enable and /Disable are mutual exclusive ShowMessage(stderr, GetResString(IDS_ENABLE_AND_DISABLE)); return EXIT_FAILURE; } // Start validations for the sub-options if( EXIT_FAILURE == ValidateChangeSuboptVal(tchgsubops, tchgoptvals, cmdChangeOptions, dwScheduleType) ) { return(EXIT_FAILURE); } return EXIT_SUCCESS; } /****************************************************************************** Routine Description: This routine validates the sub options specified by the user reg.create option & determines the type of a scheduled task. Arguments: [ out ] tchgsubops : Structure containing the task's properties [ out ] tchgoptvals : Structure containing optional values to set [ in ] cmdOptions[] : Array of type TCMDPARSER [ in ] dwScheduleType : Type of schedule[Daily,once,weekly etc] Return Value : A DWORD value indicating RETVAL_SUCCESS on success else EXIT_FAILURE on failure ******************************************************************************/ DWORD ValidateChangeSuboptVal( OUT TCHANGESUBOPTS& tchgsubops, OUT TCHANGEOPVALS &tchgoptvals, IN TCMDPARSER2 cmdOptions[], IN DWORD dwScheduleType ) { DWORD dwRetval = RETVAL_SUCCESS; BOOL bIsStDtCurDt = FALSE; // check whether the password (-p) specified in the command line or not // and also check whether '*' or empty is given for -p or not // check the remote connectivity information if ( tchgsubops.szServer != NULL ) { // // if -u is not specified, we need to allocate memory // in order to be able to retrive the current user name // // case 1: -p is not at all specified // as the value for this switch is optional, we have to rely // on the dwActuals to determine whether the switch is specified or not // in this case utility needs to try to connect first and if it fails // then prompt for the password -- in fact, we need not check for this // condition explicitly except for noting that we need to prompt for the // password // // case 2: -p is specified // but we need to check whether the value is specified or not // in this case user wants the utility to prompt for the password // before trying to connect // // case 3: -p * is specified // user name if ( tchgsubops.szUserName == NULL ) { tchgsubops.szUserName = (LPWSTR) AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) ); if ( tchgsubops.szUserName == NULL ) { SaveLastError(); return EXIT_FAILURE; } } // password if ( tchgsubops.szPassword == NULL ) { tchgoptvals.bNeedPassword = TRUE; tchgsubops.szPassword = (LPWSTR)AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) ); if ( tchgsubops.szPassword == NULL ) { SaveLastError(); return EXIT_FAILURE; } } // case 1 if ( cmdOptions[ OI_CHANGE_PASSWORD ].dwActuals == 0 ) { // we need not do anything special here } // case 2 else if ( cmdOptions[ OI_CHANGE_PASSWORD ].pValue == NULL ) { StringCopy( tchgsubops.szPassword, L"*", GetBufferSize(tchgsubops.szPassword)/sizeof(WCHAR)); } // case 3 else if ( StringCompareEx( tchgsubops.szPassword, L"*", TRUE, 0 ) == 0 ) { if ( ReallocateMemory( (LPVOID*)&tchgsubops.szPassword, MAX_STRING_LENGTH * sizeof( WCHAR ) ) == FALSE ) { SaveLastError(); return EXIT_FAILURE; } // ... tchgoptvals.bNeedPassword = TRUE; } } // validate start date if ( 1 == cmdOptions[OI_CHANGE_STARTDATE].dwActuals) { // Validate Start Date value. dwRetval = ValidateStartDate( tchgsubops.szStartDate, dwScheduleType, cmdOptions[OI_CHANGE_STARTDATE].dwActuals, bIsStDtCurDt); if(EXIT_FAILURE == dwRetval ) { return dwRetval; // Error in Day/Month string. } } // validate end date if ( 1 == cmdOptions[OI_CHANGE_ENDDATE].dwActuals ) { // Validate End Date value. dwRetval = ValidateEndDate( tchgsubops.szEndDate, dwScheduleType, cmdOptions[OI_CHANGE_ENDDATE].dwActuals); if(EXIT_FAILURE == dwRetval ) { return dwRetval; // Error in Day/Month string. } } //Check Whether end date should be greater than startdate WORD wEndDay = 0; WORD wEndMonth = 0; WORD wEndYear = 0; WORD wStartDay = 0; WORD wStartMonth = 0; WORD wStartYear = 0; if( cmdOptions[OI_CHANGE_ENDDATE].dwActuals != 0 ) { if( EXIT_FAILURE == GetDateFieldEntities( tchgsubops.szEndDate,&wEndDay, &wEndMonth,&wEndYear)) { return EXIT_FAILURE; } } // get the date fields if( ( cmdOptions[OI_CHANGE_STARTDATE].dwActuals != 0 ) && (EXIT_FAILURE == GetDateFieldEntities(tchgsubops.szStartDate, &wStartDay,&wStartMonth, &wStartYear))) { ShowMessage(stderr, GetResString(IDS_INVALID_STARTDATE) ); return EXIT_FAILURE; } // validate date format if( (cmdOptions[OI_CHANGE_ENDDATE].dwActuals != 0) ) { if( ( wEndYear == wStartYear ) ) { // For same years if the end month is less than start month or for same years and same months // if the endday is less than the startday. if ( ( wEndMonth < wStartMonth ) || ( ( wEndMonth == wStartMonth ) && ( wEndDay < wStartDay ) ) ) { ShowMessage(stderr, GetResString(IDS_ENDATE_INVALID)); return EXIT_FAILURE; } } else if ( wEndYear < wStartYear ) { ShowMessage(stderr, GetResString(IDS_ENDATE_INVALID)); return EXIT_FAILURE; } } // validate start time format if (1 == cmdOptions[OI_CHANGE_STARTTIME].dwActuals) { // Validate Start Time value. dwRetval = ValidateTimeString(tchgsubops.szStartTime); if(EXIT_FAILURE == dwRetval) { // Error. Invalid date string. ShowMessage(stderr,GetResString(IDS_INVALIDFORMAT_STARTTIME)); return dwRetval; } } // validate end time format if (1 == cmdOptions[OI_CHANGE_ENDTIME].dwActuals) { // Validate Start Time value. dwRetval = ValidateTimeString(tchgsubops.szEndTime); if(EXIT_FAILURE == dwRetval) { // Error. Invalid date string. ShowMessage(stderr,GetResString(IDS_INVALIDFORMAT_ENDTIME)); return dwRetval; } } return RETVAL_SUCCESS; } /****************************************************************************** Routine Description: Release memory Arguments: [ in ] pParam : cmdOptions structure Return Value : TRUE on success ******************************************************************************/ BOOL ReleaseChangeMemory( IN PTCHANGESUBOPTS pParams ) { // release memory FreeMemory((LPVOID *) &pParams->szServer); FreeMemory((LPVOID *) &pParams->szUserName); FreeMemory((LPVOID *) &pParams->szPassword); FreeMemory((LPVOID *) &pParams->szRunAsUserName); FreeMemory((LPVOID *) &pParams->szRunAsPassword); //reset all fields to 0 SecureZeroMemory( &pParams, sizeof( PTCHANGESUBOPTS ) ); return TRUE; }