/****************************************************************************** Copyright(c) Microsoft Corporation Module Name: create.cpp Abstract: This module validates the options specied by the user & if correct creates a scheduled task. Author: Raghu babu 10-oct-2000 Revision History: Raghu babu 10-Oct-2000 : Created it G.Surender Reddy 25-oct-2000 : Modified it G.Surender Reddy 27-oct-2000 : Modified it G.Surender Reddy 30-oct-2000 : Modified it ******************************************************************************/ //common header files needed for this file #include "pch.h" #include "CommonHeaderFiles.h" /****************************************************************************** Routine Description: This routine initialises the variables to neutral values ,helps in creating a new scheduled task Arguments: [ in ] argc : The count of arguments specified in the command line [ in ] argv : Array of command line arguments Return Value : A HRESULT value indicating S_OK on success else S_FALSE on failure ******************************************************************************/ HRESULT CreateScheduledTask(DWORD argc , LPCTSTR argv[]) { // declarations of structures TCREATESUBOPTS tcresubops; TCREATEOPVALS tcreoptvals; DWORD dwScheduleType = 0; WORD wUserStatus = FALSE; //Initialise the structure to neutral values. lstrcpy(tcresubops.szServer, NULL_STRING); lstrcpy(tcresubops.szUser, NULL_STRING); lstrcpy(tcresubops.szPassword, NULL_STRING); lstrcpy(tcresubops.szRunAsUser, NULL_STRING); lstrcpy(tcresubops.szRunAsPassword, NULL_STRING); lstrcpy(tcresubops.szSchedType, NULL_STRING); lstrcpy(tcresubops.szModifier, NULL_STRING); lstrcpy(tcresubops.szDays, NULL_STRING); lstrcpy(tcresubops.szMonths, NULL_STRING); lstrcpy(tcresubops.szIdleTime, NULL_STRING); lstrcpy(tcresubops.szTaskName, NULL_STRING); lstrcpy(tcresubops.szStartTime, NULL_STRING); lstrcpy(tcresubops.szStartDate, NULL_STRING); lstrcpy(tcresubops.szEndDate, NULL_STRING); lstrcpy(tcresubops.szTaskRun, NULL_STRING); tcresubops.bCreate = FALSE; tcresubops.bUsage = FALSE; tcreoptvals.bSetStartDateToCurDate = FALSE; tcreoptvals.bSetStartTimeToCurTime = FALSE; tcreoptvals.bPassword = FALSE; tcreoptvals.bRunAsPassword = FALSE; // process the options for -create option if( ProcessCreateOptions ( argc, argv, tcresubops, tcreoptvals, &dwScheduleType, &wUserStatus ) ) { if(tcresubops.bUsage == TRUE) { return S_OK; } else { return E_FAIL; } } // calls the function to create a scheduled task return CreateTask(tcresubops,tcreoptvals,dwScheduleType, wUserStatus ); } /****************************************************************************** Routine Description: This routine creates a new scheduled task according to the user specified format Arguments: [ in ] tcresubops : Structure containing the task's properties [ out ] tcreoptvals : Structure containing optional values to set [ in ] dwScheduleType : Type of schedule[Daily,once,weekly etc] [ in ] bUserStatus : bUserStatus will be TRUE when -ru given else FALSE Return Value : A HRESULT value indicating S_OK on success else S_FALSE on failure ******************************************************************************/ HRESULT CreateTask(TCREATESUBOPTS tcresubops, TCREATEOPVALS &tcreoptvals, DWORD dwScheduleType, WORD wUserStatus) { // Declarations related to the system time WORD wStartDay = 0; WORD wStartMonth = 0; WORD wStartYear = 0; WORD wStartHour = 0; WORD wStartMin = 0; WORD wStartSec = 0; WORD wEndDay = 0; WORD wEndYear = 0; WORD wEndMonth = 0; WORD wIdleTime = 0; SYSTEMTIME systime = {0,0,0,0,0,0,0,0}; // Declarations related to the new task WCHAR wszJobName[MAX_TASKNAME_LEN] = NULL_U_STRING; WCHAR wszTime[MAX_TIMESTR_LEN] = NULL_U_STRING; WCHAR wszUserName[MAX_STRING_LENGTH] = NULL_U_STRING; WCHAR wszPassword[MAX_STRING_LENGTH] = NULL_U_STRING; WCHAR wszCommand[_MAX_FNAME] = NULL_U_STRING; WCHAR wszApplName[_MAX_FNAME] = NULL_U_STRING; TCHAR szErrorDesc[MAX_RES_STRING] = NULL_STRING; TCHAR szRPassword[MAX_USERNAME_LENGTH] = NULL_STRING; HRESULT hr = S_OK; IPersistFile *pIPF = NULL; ITask *pITask = NULL; ITaskTrigger *pITaskTrig = NULL; ITaskScheduler *pITaskScheduler = NULL; WORD wTrigNumber = 0; TASK_TRIGGER TaskTrig; ZeroMemory(&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. _TCHAR* szValues[1] = {NULL};//To pass to FormatMessage() API // Buffer to store the string obtained from the string table TCHAR szBuffer[MAX_STRING_LENGTH] = NULL_STRING; BOOL bPassWord = FALSE; BOOL bUserName = FALSE; BOOL bRet = FALSE; BOOL bResult = FALSE; BOOL bCloseConnection = TRUE; ULONG ulLong = MAX_RES_STRING; BOOL bVal = FALSE; // check whether the taskname contains the characters such // as '<','>',':','/','\\','|' bRet = VerifyJobName(tcresubops.szTaskName); if(bRet == FALSE) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_TASKNAME1)); DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_TASKNAME2)); Cleanup(pITaskScheduler); return E_FAIL; } // check for the length of taskname if( ( lstrlen(tcresubops.szTaskName) > MAX_JOB_LEN ) || ( lstrlen(tcresubops.szTaskName) == 0 ) ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_TASKLENGTH)); Cleanup(pITaskScheduler); return E_FAIL; } // check for the length of taskrun if(( lstrlen(tcresubops.szTaskRun) > MAX_TASK_LEN ) || ( lstrlen(tcresubops.szTaskRun) == 0 ) ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_TASKRUN)); Cleanup(pITaskScheduler); return E_FAIL; } // check for the length of username if( ( lstrlen(tcresubops.szRunAsUser) > MAX_USERNAME_LENGTH ) || ( lstrlen(tcresubops.szUser) > MAX_USERNAME_LENGTH ) ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_UNAME )); Cleanup(pITaskScheduler); return E_FAIL; } // check for the length of password if( ( lstrlen(tcresubops.szRunAsPassword) > MAX_PASSWORD_LENGTH ) || ( lstrlen(tcresubops.szPassword) > MAX_PASSWORD_LENGTH ) ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( ( tcreoptvals.bRunAsPassword == TRUE ) && ( lstrlen(tcresubops.szRunAsPassword) == 0 ) && ( lstrlen ( tcresubops.szRunAsUser ) != 0 ) && ( lstrcmpi(tcresubops.szRunAsUser, NTAUTHORITY_USER ) != 0 ) && ( lstrcmpi(tcresubops.szRunAsUser, SYSTEM_USER ) != 0 ) ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // Convert the task name specified by the user to wide char or unicode format if( GetAsUnicodeString(tcresubops.szTaskName,wszJobName,SIZE_OF_ARRAY(wszJobName) ) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } // Convert the start time specified by the user to wide char or unicode format if(GetAsUnicodeString(tcresubops.szStartTime,wszTime,SIZE_OF_ARRAY(wszTime)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } // Convert the task to run specified by the user to wide char or unicode format if( GetAsUnicodeString(tcresubops.szTaskRun,wszCommand,SIZE_OF_ARRAY(wszCommand)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for the local system if ( ( IsLocalSystem( tcresubops.szServer ) == TRUE ) && ( lstrlen ( tcresubops.szRunAsUser ) != 0 ) && ( lstrcmpi(tcresubops.szRunAsUser, NTAUTHORITY_USER ) != 0 ) && ( lstrcmpi(tcresubops.szRunAsUser, SYSTEM_USER ) != 0 ) ) { // Establish the connection on a remote machine bResult = EstablishConnection(tcresubops.szServer,tcresubops.szUser,SIZE_OF_ARRAY(tcresubops.szUser),tcresubops.szPassword,SIZE_OF_ARRAY(tcresubops.szPassword), !(tcreoptvals.bPassword)); if (bResult == FALSE) { DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR_STRING) ); DISPLAY_MESSAGE( stderr, GetReason()); Cleanup(pITaskScheduler); 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; DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR_STRING) ); DISPLAY_MESSAGE( stderr, GetReason()); Cleanup(pITaskScheduler); return EXIT_FAILURE; } } } if ( lstrlen (tcresubops.szRunAsUser) != 0 ) { // Convert the user name specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szRunAsUser, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } bUserName = TRUE; if ( tcreoptvals.bRunAsPassword == FALSE ) { szValues[0] = (_TCHAR*) (wszUserName); //Display that the task will be created under logged in user name,ask for password MessageBeep(MB_ICONEXCLAMATION); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // getting the password if (GetPassword(szRPassword, MAX_PASSWORD_LENGTH) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( szRPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen( szRPassword ) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } if(lstrlen(szRPassword)) { // Convert the password specified by the user to wide char or unicode format if (GetAsUnicodeString(szRPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } bPassWord = TRUE; } else { // Convert the password specified by the user to wide char or unicode format if (GetAsUnicodeString(tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } bPassWord = TRUE; } } } // check whether -s option only specified in the cmd line or not else if( ( IsLocalSystem( tcresubops.szServer ) == FALSE ) && ( wUserStatus == OI_SERVER ) ) { // Establish the connection on a remote machine bResult = EstablishConnection(tcresubops.szServer,tcresubops.szUser,SIZE_OF_ARRAY(tcresubops.szUser),tcresubops.szPassword,SIZE_OF_ARRAY(tcresubops.szPassword), !(tcreoptvals.bPassword)); if (bResult == FALSE) { DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR_STRING) ); DISPLAY_MESSAGE( stderr, GetReason()); Cleanup(pITaskScheduler); 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; DISPLAY_MESSAGE( stdout, GetResString(IDS_ERROR_STRING) ); DISPLAY_MESSAGE( stdout, GetReason()); Cleanup(pITaskScheduler); return EXIT_FAILURE; } } } if ( ( bCloseConnection == FALSE ) && ( lstrlen (tcresubops.szUser) == 0 ) ) { //get the current logged on username if ( GetUserNameEx ( NameSamCompatible, tcresubops.szUser , &ulLong) == FALSE ) { DISPLAY_MESSAGE( stderr, GetResString( IDS_LOGGED_USER_ERR ) ); Cleanup(pITaskScheduler); return E_FAIL; } bUserName = TRUE; // Convert the user name specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szUser, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } szValues[0] = (_TCHAR*) (wszUserName); //Display that the task will be created under logged in user name,ask for password MessageBeep(MB_ICONEXCLAMATION); // format the message for currently logged-on user name FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_TASK_INFO),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // format the message for getting the password from the console FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); if (GetPassword(tcresubops.szRunAsPassword, MAX_PASSWORD_LENGTH) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( tcresubops.szRunAsPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen( tcresubops.szRunAsPassword ) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // check for the length of the password if(lstrlen(tcresubops.szRunAsPassword)) { // Convert the password specified by the user to wide char or unicode format if (GetAsUnicodeString(tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } bPassWord = TRUE; } // Convert the user name specified by the user to wide char or unicode format if( GetAsUnicodeString(tcresubops.szUser,wszUserName,SIZE_OF_ARRAY(wszUserName)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } // check whether the run as password is specified in the cmdline or not if ( tcreoptvals.bRunAsPassword == TRUE ) { // check for -rp "*" or -rp " " to prompt for password if ( lstrcmpi( tcresubops.szRunAsPassword, ASTERIX ) == 0 ) { // format the message for getting the password szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // Get the run as password from the command line if ( GetPassword(tcresubops.szRunAsPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( tcresubops.szRunAsPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of the password if( lstrlen(tcresubops.szRunAsPassword) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } } else { // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } // set the BOOL variables to TRUE bUserName = TRUE; bPassWord = TRUE; } // check for -s and -u options only specified in the cmd line or not else if ( wUserStatus == OI_USERNAME ) { // Establish the connection on a remote machine bResult = EstablishConnection(tcresubops.szServer,tcresubops.szUser,SIZE_OF_ARRAY(tcresubops.szUser),tcresubops.szPassword,SIZE_OF_ARRAY(tcresubops.szPassword), !(tcreoptvals.bPassword)); if (bResult == FALSE) { DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR_STRING) ); DISPLAY_MESSAGE( stderr, GetReason()); Cleanup(pITaskScheduler); return EXIT_FAILURE ; } else { // though the connection is successfull, some conflict might have occured switch( GetLastError() ) { case I_NO_CLOSE_CONNECTION: bCloseConnection = FALSE; break; // for mismatched credentials case E_LOCAL_CREDENTIALS: case ERROR_SESSION_CREDENTIAL_CONFLICT: { bCloseConnection = FALSE; DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR_STRING) ); DISPLAY_MESSAGE( stderr, GetReason()); Cleanup(pITaskScheduler); return EXIT_FAILURE; } } } // Convert the user name specified by the user to wide char or unicode format if( GetAsUnicodeString(tcresubops.szUser,wszUserName,SIZE_OF_ARRAY(wszUserName)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } // check whether run as password is specified in the command line or not if ( tcreoptvals.bRunAsPassword == TRUE ) { // check for -rp "*" or -rp " " to prompt for password if ( lstrcmpi( tcresubops.szRunAsPassword, ASTERIX ) == 0 ) { // format the message for getting the password from console szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // Get the password from the command line if ( GetPassword(tcresubops.szRunAsPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( tcresubops.szRunAsPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen(tcresubops.szRunAsPassword) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } else { // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } bPassWord = TRUE; } } else { if ( lstrlen(tcresubops.szPassword) != 0 ) { // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } else { // format the message for getting the password from console szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // Get the password from the command line if ( GetPassword(tcresubops.szRunAsPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( tcresubops.szRunAsPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen(tcresubops.szRunAsPassword) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } } bUserName = TRUE; bPassWord = TRUE; } // check for -s, -ru or -u options specified in the cmd line or not else if ( ( lstrlen (tcresubops.szServer) != 0 ) && ( wUserStatus == OI_RUNASUSERNAME || wUserStatus == OI_RUNANDUSER ) ) { // Establish the connection on a remote machine bResult = EstablishConnection(tcresubops.szServer,tcresubops.szUser,SIZE_OF_ARRAY(tcresubops.szUser),tcresubops.szPassword,SIZE_OF_ARRAY(tcresubops.szPassword), !(tcreoptvals.bPassword)); if (bResult == FALSE) { DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR_STRING) ); DISPLAY_MESSAGE( stderr, GetReason()); Cleanup(pITaskScheduler); return EXIT_FAILURE ; } else { // though the connection is successfull, some conflict might have occured switch( GetLastError() ) { case I_NO_CLOSE_CONNECTION: bCloseConnection = FALSE; break; case E_LOCAL_CREDENTIALS: case ERROR_SESSION_CREDENTIAL_CONFLICT: { bCloseConnection = FALSE; DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR_STRING) ); DISPLAY_MESSAGE( stderr, GetReason()); Cleanup(pITaskScheduler); return EXIT_FAILURE; } } } if ( ( ( lstrlen ( tcresubops.szRunAsUser ) == 0 ) || ( lstrcmpi( tcresubops.szRunAsUser, NTAUTHORITY_USER ) == 0 ) || ( lstrcmpi( tcresubops.szRunAsUser, SYSTEM_USER ) == 0 ) ) ) { // Convert the run as user name specified by the user to wide char or unicode format if( GetAsUnicodeString(tcresubops.szRunAsUser,wszUserName,SIZE_OF_ARRAY(wszUserName)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } szValues[0] = (_TCHAR*) (wszJobName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_NTAUTH_SYSTEM_INFO),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); if ( ( tcreoptvals.bRunAsPassword == TRUE ) && ( lstrlen (tcresubops.szRunAsPassword) != 0 ) ) { DISPLAY_MESSAGE( stdout, GetResString( IDS_PASSWORD_NOEFFECT ) ); } bUserName = TRUE; bPassWord = TRUE; bVal = TRUE; } else { // check for the length of password if ( lstrlen ( tcresubops.szRunAsUser ) != 0 ) { // Convert the run as user name specified by the user to wide char or unicode format if( GetAsUnicodeString(tcresubops.szRunAsUser,wszUserName,SIZE_OF_ARRAY(wszUserName)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } bUserName = TRUE; } } // check whether -u and -ru are the same or not. if they are same, we need to // prompt for the run as password. otherwise, will consoder -rp as -p if ( lstrcmpi( tcresubops.szRunAsUser, tcresubops.szUser ) != 0) { if ( tcreoptvals.bRunAsPassword == TRUE ) { if ( (lstrlen(tcresubops.szRunAsUser) != 0) && (lstrcmpi( tcresubops.szRunAsPassword, ASTERIX ) == 0 ) && ( lstrcmpi( tcresubops.szRunAsUser, NTAUTHORITY_USER ) != 0 ) && ( lstrcmpi( tcresubops.szRunAsUser, SYSTEM_USER ) != 0 ) ) { szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // prompt for the run as password if ( GetPassword(szRPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( szRPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen(szRPassword) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( szRPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } bUserName = TRUE; bPassWord = TRUE; } else { // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } bUserName = TRUE; bPassWord = TRUE; } } else { // check for the length of password if ( ( bVal == FALSE ) && ( lstrlen(tcresubops.szRunAsUser) != 0) ) { // format the message for getting the password from console szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // prompt for the run as password if ( GetPassword(szRPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( szRPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen(szRPassword) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( szRPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } bUserName = TRUE; bPassWord = TRUE; } } else { // check whether run as password is specified in the cmdline or not if ( tcreoptvals.bRunAsPassword == TRUE ) { if ( ( lstrlen ( tcresubops.szRunAsUser ) != 0 ) && ( lstrcmpi( tcresubops.szRunAsPassword, ASTERIX ) == 0 ) ) { szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // prompt for the run as password if ( GetPassword(szRPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( szRPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen(szRPassword) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( szRPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } else { // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } } else { if ( lstrlen (tcresubops.szPassword) ) { // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } else { if (( lstrlen ( tcresubops.szRunAsUser ) != 0 ) && ( lstrcmpi(tcresubops.szRunAsUser, NTAUTHORITY_USER ) != 0 ) && ( lstrcmpi(tcresubops.szRunAsUser, SYSTEM_USER ) != 0 ) ) { szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // prompt for the run as password if ( GetPassword(szRPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( szRPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen(szRPassword) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString( szRPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } } } bUserName = TRUE; bPassWord = TRUE; } } // To check for the -ru values "", "NT AUTHORITY\SYSTEM", "SYSTEM" if( ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME ) && ( lstrlen( tcresubops.szRunAsUser) == 0 ) && ( tcreoptvals.bRunAsPassword == FALSE ) ) || ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME ) && ( lstrlen( tcresubops.szRunAsUser) == 0 ) && ( lstrlen(tcresubops.szRunAsPassword ) == 0 ) ) || ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME ) && ( lstrcmpi(tcresubops.szRunAsUser, NTAUTHORITY_USER ) == 0 ) && ( tcreoptvals.bRunAsPassword == FALSE ) ) || ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME ) && ( lstrcmpi(tcresubops.szRunAsUser, NTAUTHORITY_USER ) == 0 ) && ( lstrlen( tcresubops.szRunAsPassword) == 0 ) ) || ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME ) && ( lstrcmpi(tcresubops.szRunAsUser, SYSTEM_USER ) == 0 ) && ( tcreoptvals.bRunAsPassword == FALSE ) ) || ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME ) && ( lstrcmpi(tcresubops.szRunAsUser, SYSTEM_USER ) == 0 ) && ( lstrlen(tcresubops.szRunAsPassword) == 0 ) ) ) { //format the message to display the taskname will be created under "NT AUTHORITY\SYSTEM" szValues[0] = (_TCHAR*) (wszJobName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_NTAUTH_SYSTEM_INFO),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); bUserName = TRUE; bPassWord = TRUE; bVal = TRUE; } // check whether the -rp value is given with the -ru "", "NT AUTHORITY\SYSTEM", // "SYSTEM" or not else if( ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME || wUserStatus == OI_RUNANDUSER) && ( lstrlen(tcresubops.szRunAsUser) == 0 ) && ( lstrlen(tcresubops.szRunAsPassword) != 0 ) ) || ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME || wUserStatus == OI_RUNANDUSER) && ( lstrcmpi( tcresubops.szRunAsUser, NTAUTHORITY_USER ) == 0 ) && ( tcreoptvals.bRunAsPassword == TRUE ) ) || ( ( bVal == FALSE ) && ( wUserStatus == OI_RUNASUSERNAME || wUserStatus == OI_RUNANDUSER) && ( lstrcmpi( tcresubops.szRunAsUser, SYSTEM_USER ) == 0 ) && ( tcreoptvals.bRunAsPassword == TRUE ) ) ) { szValues[0] = (_TCHAR*) (wszJobName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_NTAUTH_SYSTEM_INFO),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // to display a warning message as password will not effect for the system account DISPLAY_MESSAGE( stdout, GetResString( IDS_PASSWORD_NOEFFECT ) ); bUserName = TRUE; bPassWord = TRUE; bVal = TRUE; } // check whether -s, -u, -ru options are given in the cmdline or not else if( ( wUserStatus != OI_SERVER ) && ( wUserStatus != OI_USERNAME ) && ( wUserStatus != OI_RUNASUSERNAME ) && ( wUserStatus != OI_RUNANDUSER ) && ( lstrcmpi( tcresubops.szRunAsPassword , NULL_STRING ) == 0 ) ) { if (tcreoptvals.bRunAsPassword == TRUE) { bPassWord = TRUE; } else { bPassWord = FALSE; } } else if ( ( lstrlen(tcresubops.szServer) == 0 ) && (lstrlen ( tcresubops.szRunAsUser ) != 0 ) ) { // Convert the run as user name specified by the user to wide char or unicode format if ( GetAsUnicodeString( tcresubops.szRunAsUser, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } bUserName = TRUE; if ( lstrlen ( tcresubops.szRunAsPassword ) == 0 ) { bPassWord = TRUE; } else { // check whether "*" or NULL value is given for -rp or not if ( lstrcmpi ( tcresubops.szRunAsPassword , ASTERIX ) == 0 ) { // format a message for getting the password from the console szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // Get the password from the command line if (GetPassword(szRPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( szRPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen( szRPassword ) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } if(lstrlen(szRPassword)) { // Convert the password specified by the user to wide char or unicode format if (GetAsUnicodeString(szRPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } } else { // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString(tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } bPassWord = TRUE; } } // check whether -ru or -u values are specified in the cmdline or not if ( wUserStatus == OI_RUNASUSERNAME || wUserStatus == OI_RUNANDUSER ) { if( ( bUserName == TRUE ) && ( bPassWord == FALSE ) ) { szValues[0] = (_TCHAR*) (wszUserName); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // getting the password from the console if ( GetPassword(tcresubops.szRunAsPassword, MAX_PASSWORD_LENGTH ) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( tcresubops.szRunAsPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen(tcresubops.szRunAsPassword) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } if(lstrlen(tcresubops.szRunAsPassword)) { // Convert the password specified by the user to wide char or unicode format if ( GetAsUnicodeString(tcresubops.szRunAsPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } } } //if the user name is not specifed set the current logged on user settings DWORD dwUserLen = MAX_USERNAME_LEN; DWORD dwResult = 0; _TCHAR szUserName[MAX_RES_STRING]; #ifdef _WIN64 INT64 dwPos = 0; #else DWORD dwPos = 0; #endif if( ( bUserName == FALSE ) ) { //get the current logged on username if ( GetUserNameEx ( NameSamCompatible, szUserName , &ulLong) == FALSE ) { DISPLAY_MESSAGE( stderr, GetResString( IDS_LOGGED_USER_ERR ) ); Cleanup(pITaskScheduler); return E_FAIL; } // Convert the user name specified by the user to wide char or unicode format if ( GetAsUnicodeString( szUserName, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } szValues[0] = (_TCHAR*) (wszUserName); //Display that the task will be created under logged in user name,ask for password MessageBeep(MB_ICONEXCLAMATION); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_TASK_INFO),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_PROMPT_PASSWD),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // getting the password if (GetPassword(szRPassword, MAX_PASSWORD_LENGTH) == FALSE ) { Cleanup(pITaskScheduler); return E_FAIL; } // check for empty password if( lstrlen ( szRPassword ) == 0 ) { DISPLAY_MESSAGE(stdout, GetResString(IDS_WARN_EMPTY_PASSWORD)); } // check for the length of password if( lstrlen( szRPassword ) > MAX_PASSWORD_LENGTH ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD)); Cleanup(pITaskScheduler); return E_FAIL; } if(lstrlen(szRPassword)) { // Convert the password specified by the user to wide char or unicode format if (GetAsUnicodeString(szRPassword,wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL ) { Cleanup(pITaskScheduler); return E_FAIL; } } } // Get the task Scheduler object for the machine. pITaskScheduler = GetTaskScheduler( tcresubops.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( tcresubops.szServer ); Cleanup(pITaskScheduler); return E_FAIL; } // create a work item wszJobName hr = pITaskScheduler->NewWorkItem(wszJobName,CLSID_CTask,IID_ITask, (IUnknown**)&pITask); if(hr == HRESULT_FROM_WIN32 (ERROR_FILE_EXISTS)) { DISPLAY_MESSAGE(stderr,GetResString(IDS_CREATE_TASK_EXISTS)); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } if (FAILED(hr)) { DisplayErrorMsg(hr); // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } // Return a pointer to a specified interface on an object hr = pITask->QueryInterface(IID_IPersistFile, (void **) &pIPF); if (FAILED(hr)) { DisplayErrorMsg(hr); if( pIPF ) { pIPF->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } // declaration for parameter arguments wchar_t wcszParam[MAX_RES_STRING] = L""; DWORD dwProcessCode = 0 ; dwProcessCode = ProcessFilePath(wszCommand,wszApplName,wcszParam); if(dwProcessCode == RETVAL_FAIL) { if( pIPF ) { pIPF->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } // check for .exe substring string in the given task to run string // Set command name with ITask::SetApplicationName hr = pITask->SetApplicationName(wszApplName); if (FAILED(hr)) { DisplayErrorMsg(hr); if( pIPF ) { pIPF->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } //[Working directory = exe pathname - exe name] wchar_t* wcszStartIn = wcsrchr(wszApplName,_T('\\')); if(wcszStartIn != NULL) *( wcszStartIn ) = _T('\0'); // set the command working directory hr = pITask->SetWorkingDirectory(wszApplName); if (FAILED(hr)) { DisplayErrorMsg(hr); if( pIPF ) { pIPF->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } // set the command line parameters for the task hr = pITask->SetParameters(wcszParam); if (FAILED(hr)) { DisplayErrorMsg(hr); if( pIPF ) { pIPF->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } // set the flag TASK_FLAG_DELETE_WHEN_DONE DWORD dwTaskFlags = TASK_FLAG_DELETE_WHEN_DONE; hr = pITask->SetFlags(dwTaskFlags); if (FAILED(hr)) { DisplayErrorMsg(hr); if( pIPF ) { pIPF->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } if ( bVal == TRUE ) { // Set account information for "NT AUTHORITY\SYSTEM" user hr = pITask->SetAccountInformation(L"",NULL); } 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)) { DisplayErrorMsg(hr); DISPLAY_MESSAGE ( stdout, _T("\n") ); DISPLAY_MESSAGE ( stdout, GetResString( IDS_ACCNAME_ERR ) ); if( pIPF ) { pIPF->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } //Assign start date if(tcreoptvals.bSetStartDateToCurDate ) { GetLocalTime(&systime); wStartDay = systime.wDay; wStartMonth = systime.wMonth; wStartYear = systime.wYear; } else if(lstrlen(tcresubops.szStartDate) > 0) { GetDateFieldEntities(tcresubops.szStartDate, &wStartDay, &wStartMonth, &wStartYear); } //Assign start time if(tcreoptvals.bSetStartTimeToCurTime && (dwScheduleType != SCHED_TYPE_ONIDLE) ) { GetLocalTime(&systime); wStartHour = systime.wHour; wStartMin = systime.wMinute; wStartSec = systime.wSecond; } else if(lstrlen(tcresubops.szStartTime) > 0) { GetTimeFieldEntities(tcresubops.szStartTime, &wStartHour, &wStartMin, &wStartSec); } //Set the falgs specific to ONIDLE if(dwScheduleType == SCHED_TYPE_ONIDLE) { pITask->SetFlags(TASK_FLAG_START_ONLY_IF_IDLE); wIdleTime = (WORD)AsLong(tcresubops.szIdleTime, BASE_TEN); pITask->SetIdleWait(wIdleTime, 0); } //create trigger for the corresponding task hr = pITask->CreateTrigger(&wTrigNumber, &pITaskTrig); if (FAILED(hr)) { DisplayErrorMsg(hr); if( pIPF ) { pIPF->Release(); } if( pITaskTrig ) { pITaskTrig->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } DWORD dwTrigFlags = 0; WORD wWhichWeek; LONG lMonthlyModifier = 0; DWORD dwDays = 1; switch( dwScheduleType ) { case SCHED_TYPE_MINUTE: TaskTrig.TriggerType = TASK_TIME_TRIGGER_DAILY; TaskTrig.Type.Daily.DaysInterval = 1; TaskTrig.MinutesInterval = AsLong(tcresubops.szModifier, BASE_TEN); TaskTrig.MinutesDuration = (WORD)(HOURS_PER_DAY*MINUTES_PER_HOUR); TaskTrig.wStartHour = wStartHour; TaskTrig.wStartMinute = wStartMin; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; if(lstrlen(tcresubops.szEndDate) > 0) { // Make end date valid; otherwise the enddate parameter is ignored. TaskTrig.rgFlags = TASK_TRIGGER_FLAG_HAS_END_DATE; // Now set the end date entities. GetDateFieldEntities(tcresubops.szEndDate, &wEndDay, &wEndMonth, &wEndYear); TaskTrig.wEndDay = wEndDay; TaskTrig.wEndMonth = wEndMonth; TaskTrig.wEndYear = wEndYear; } break; case SCHED_TYPE_HOURLY: TaskTrig.TriggerType = TASK_TIME_TRIGGER_DAILY; TaskTrig.Type.Daily.DaysInterval = 1; TaskTrig.MinutesInterval = (WORD)(AsLong(tcresubops.szModifier, BASE_TEN) * MINUTES_PER_HOUR); TaskTrig.MinutesDuration = (WORD)(HOURS_PER_DAY*MINUTES_PER_HOUR); TaskTrig.wStartHour = wStartHour; TaskTrig.wStartMinute = wStartMin; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; // Now set end date parameters, if the enddate is specified. if(lstrlen(tcresubops.szEndDate) > 0) { // Make end date valid; otherwise the enddate parameter is ignored. TaskTrig.rgFlags = TASK_TRIGGER_FLAG_HAS_END_DATE; // Now set the end date entities. GetDateFieldEntities(tcresubops.szEndDate, &wEndDay, &wEndMonth, &wEndYear); TaskTrig.wEndDay = wEndDay; TaskTrig.wEndMonth = wEndMonth; TaskTrig.wEndYear = wEndYear; } break; // Schedule type is Daily case SCHED_TYPE_DAILY: TaskTrig.TriggerType = TASK_TIME_TRIGGER_DAILY; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; TaskTrig.wStartHour = wStartHour; TaskTrig.wStartMinute = wStartMin; if( lstrlen(tcresubops.szModifier) > 0 ) { // Set the duration between days to the modifier value specified, if the modifier is specified. TaskTrig.Type.Daily.DaysInterval = (WORD) AsLong(tcresubops.szModifier, BASE_TEN); } else { // Set value for on which day of the week? TaskTrig.Type.Weekly.rgfDaysOfTheWeek = GetTaskTrigwDayForDay(tcresubops.szDays); TaskTrig.Type.Weekly.WeeksInterval = 1; } // Now set end date parameters, if the enddate is specified. if(lstrlen(tcresubops.szEndDate) > 0) { // Make end date valid; otherwise the enddate parameter is ignored. TaskTrig.rgFlags = TASK_TRIGGER_FLAG_HAS_END_DATE; // Now set the end date entities. GetDateFieldEntities(tcresubops.szEndDate, &wEndDay, &wEndMonth, &wEndYear); TaskTrig.wEndDay = wEndDay; TaskTrig.wEndMonth = wEndMonth; TaskTrig.wEndYear = wEndYear; } // No more settings for a Daily type scheduled item. break; // Schedule type is Weekly case SCHED_TYPE_WEEKLY: TaskTrig.TriggerType = TASK_TIME_TRIGGER_WEEKLY; TaskTrig.Type.Weekly.WeeksInterval = (WORD)AsLong(tcresubops.szModifier, BASE_TEN); // Set value for on which day of the week? TaskTrig.Type.Weekly.rgfDaysOfTheWeek = GetTaskTrigwDayForDay(tcresubops.szDays); TaskTrig.wStartHour = wStartHour; TaskTrig.wStartMinute = wStartMin; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; // Now set end date parameters, if the enddate is specified. if(lstrlen(tcresubops.szEndDate) > 0) { // Make end date valid; otherwise the enddate parameter is ignored. TaskTrig.rgFlags = TASK_TRIGGER_FLAG_HAS_END_DATE; // Now set the end date entities. GetDateFieldEntities(tcresubops.szEndDate, &wEndDay, &wEndMonth, &wEndYear); TaskTrig.wEndDay = wEndDay; TaskTrig.wEndMonth = wEndMonth; TaskTrig.wEndYear = wEndYear; } break; // Schedule type is Monthly case SCHED_TYPE_MONTHLY: TaskTrig.wStartHour = wStartHour; TaskTrig.wStartMinute = wStartMin; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; // Now set end date parameters, if the enddate is specified. if(lstrlen(tcresubops.szEndDate) > 0) { // Make end date valid; otherwise the enddate parameter is ignored. TaskTrig.rgFlags = TASK_TRIGGER_FLAG_HAS_END_DATE; // Set the end date entities. GetDateFieldEntities(tcresubops.szEndDate, &wEndDay, &wEndMonth, &wEndYear); TaskTrig.wEndDay = wEndDay; TaskTrig.wEndMonth = wEndMonth; TaskTrig.wEndYear = wEndYear; } //Find out from modifier which option like 1 - 12 days //or FIRST,SECOND ,THIRD ,.... LAST. if(lstrlen(tcresubops.szModifier) > 0) { lMonthlyModifier = AsLong(tcresubops.szModifier, BASE_TEN); if(lMonthlyModifier >= 1 && lMonthlyModifier <= 12) { if(lstrlen(tcresubops.szDays) == 0 ) { dwDays = 1;//default value for days } else { dwDays = (WORD)AsLong(tcresubops.szDays, BASE_TEN); } TaskTrig.TriggerType = TASK_TIME_TRIGGER_MONTHLYDATE; //set the appropriate day bit in rgfDays TaskTrig.Type.MonthlyDate.rgfDays = (1 << (dwDays -1)) ; TaskTrig.Type.MonthlyDate.rgfMonths = GetMonthId(lMonthlyModifier); } else { if( lstrcmpi( tcresubops.szModifier , GetResString( IDS_DAY_MODIFIER_LASTDAY ) ) == 0) { TaskTrig.TriggerType = TASK_TIME_TRIGGER_MONTHLYDATE; //set the appropriate day bit in rgfDays TaskTrig.Type.MonthlyDate.rgfDays = (1 << (GetNumDaysInaMonth(tcresubops.szMonths, wStartYear ) -1)); TaskTrig.Type.MonthlyDate.rgfMonths = GetTaskTrigwMonthForMonth( tcresubops.szMonths); break; } if( lstrcmpi(tcresubops.szModifier, GetResString( IDS_TASK_FIRSTWEEK ) ) == 0 ) { wWhichWeek = TASK_FIRST_WEEK; } else if( lstrcmpi(tcresubops.szModifier, GetResString( IDS_TASK_SECONDWEEK )) == 0 ) { wWhichWeek = TASK_SECOND_WEEK; } else if( lstrcmpi(tcresubops.szModifier, GetResString( IDS_TASK_THIRDWEEK )) == 0 ) { wWhichWeek = TASK_THIRD_WEEK; } else if( lstrcmpi(tcresubops.szModifier, GetResString( IDS_TASK_FOURTHWEEK )) == 0 ) { wWhichWeek = TASK_FOURTH_WEEK; } else if( lstrcmpi(tcresubops.szModifier, GetResString( IDS_TASK_LASTWEEK )) == 0 ) { wWhichWeek = TASK_LAST_WEEK; } TaskTrig.TriggerType = TASK_TIME_TRIGGER_MONTHLYDOW; TaskTrig.Type.MonthlyDOW.wWhichWeek = wWhichWeek; TaskTrig.Type.MonthlyDOW.rgfDaysOfTheWeek = GetTaskTrigwDayForDay( tcresubops.szDays); TaskTrig.Type.MonthlyDOW.rgfMonths = GetTaskTrigwMonthForMonth( tcresubops.szMonths); } } else { TaskTrig.TriggerType = TASK_TIME_TRIGGER_MONTHLYDATE; TaskTrig.Type.MonthlyDate.rgfMonths = GetTaskTrigwMonthForMonth( tcresubops.szMonths); dwDays = (WORD)AsLong(tcresubops.szDays, BASE_TEN); if(dwDays > 1) { //set the appropriate day bit in rgfDays TaskTrig.Type.MonthlyDate.rgfDays = (1 << (dwDays -1)); } else { TaskTrig.Type.MonthlyDate.rgfDays = 1; } } break; // Schedule type is Onetime case SCHED_TYPE_ONETIME: TaskTrig.TriggerType = TASK_TIME_TRIGGER_ONCE; TaskTrig.wStartHour = wStartHour; TaskTrig.wStartMinute = wStartMin; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; break; // Schedule type is Onlogon case SCHED_TYPE_ONSTART: case SCHED_TYPE_ONLOGON: if(dwScheduleType == SCHED_TYPE_ONLOGON ) TaskTrig.TriggerType = TASK_EVENT_TRIGGER_AT_LOGON; if(dwScheduleType == SCHED_TYPE_ONSTART ) TaskTrig.TriggerType = TASK_EVENT_TRIGGER_AT_SYSTEMSTART; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; break; // Schedule type is Onidle case SCHED_TYPE_ONIDLE: TaskTrig.TriggerType = TASK_EVENT_TRIGGER_ON_IDLE; TaskTrig.wBeginDay = wStartDay; TaskTrig.wBeginMonth = wStartMonth; TaskTrig.wBeginYear = wStartYear; break; default: // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return E_FAIL; } szValues[0] = (_TCHAR*) (tcresubops.szTaskName); // set the task trigger hr = pITaskTrig->SetTrigger(&TaskTrig); if (hr != S_OK) { FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_CREATEFAIL_INVALIDARGS),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stderr, szBuffer); if( pIPF ) { pIPF->Release(); } if( pITaskTrig ) { pITaskTrig->Release(); } if( pITask ) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } // save the copy of an object hr = pIPF->Save(NULL,TRUE); if( FAILED(hr) ) { szValues[0] = (_TCHAR*) (tcresubops.szTaskName); if ( hr == SCHEDULER_NOT_RUNNING_ERROR_CODE ) { // displays the warning message for an invalid username FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_SCHEDULER_NOT_RUNNING),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); } else if ( hr == RPC_SERVER_NOT_AVAILABLE ) { szValues[1] = (_TCHAR*) (tcresubops.szServer); // displays the warning message for an invalid username FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_RPC_SERVER_NOT_AVAIL),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); } else { // displays the warning message for an invalid username FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_INVALID_USER),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); } DISPLAY_MESSAGE(stdout, szBuffer); if(pIPF) { pIPF->Release(); } if(pITaskTrig) { pITaskTrig->Release(); } if(pITask) { pITask->Release(); } // close the connection that was established by the utility if ( bCloseConnection == TRUE ) CloseConnection( tcresubops.szServer ); Cleanup(pITaskScheduler); return EXIT_SUCCESS; } //displays success message for valid user FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_CREATE_SUCCESSFUL),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); // Release interface pointers 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( tcresubops.szServer ); Cleanup(pITaskScheduler); return hr; } /****************************************************************************** Routine Description: This routine displays the create option usage Arguments: None Return Value : None ******************************************************************************/ DWORD DisplayCreateUsage() { TCHAR szBuffer[MAX_STRING_LENGTH] = NULL_STRING; _TCHAR* szValues[1] = {NULL};//To pass to FormatMessage() API TCHAR szFormat[MAX_DATE_STR_LEN] = NULL_STRING; WORD wFormatID = 0; if ( GetDateFormatString( szFormat) ) { return RETVAL_FAIL; } szValues[0] = (_TCHAR*) (szFormat); // Displaying Create usage for( DWORD dw = IDS_CREATE_HLP1; dw <= IDS_CREATE_HLP96; dw++ ) { if ( dw == IDS_CREATE_HLP63) { // To format start date FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_CREATE_HLP63),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); } else if ( dw == IDS_CREATE_HLP66 ) { // To format end date FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_CREATE_HLP66),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); } else if ( dw == IDS_CREATE_HLP87 ) { // get the date format if ( RETVAL_FAIL == GetDateFieldFormat( &wFormatID )) { return RETVAL_FAIL; } if ( wFormatID == 0) { lstrcpy (szValues[0], GetResString (IDS_MMDDYY_VALUE)); } else if ( wFormatID == 1) { lstrcpy (szValues[0], GetResString (IDS_DDMMYY_VALUE)); } else { lstrcpy (szValues[0], GetResString (IDS_YYMMDD_VALUE)); } // To format -sd and -ed values FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, GetResString(IDS_CREATE_HLP87),0,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),szBuffer, MAX_STRING_LENGTH,(va_list*)szValues ); DISPLAY_MESSAGE(stdout,szBuffer); } else { DISPLAY_MESSAGE(stdout,GetResString(dw)); } } return RETVAL_FAIL; } /****************************************************************************** Routine Description: This routine 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. [ in ] argv : Array containing the command line arguments. [ in ] tcresubops : Structure containing Scheduled task's properties. [ in ] tcreoptvals : 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 RETVAL_FAIL on failure ******************************************************************************/ DWORD ProcessCreateOptions(DWORD argc, LPCTSTR argv[],TCREATESUBOPTS &tcresubops, TCREATEOPVALS &tcreoptvals, DWORD* pdwRetScheType, WORD *pwUserStatus) { DWORD dwScheduleType = 0; BOOL bRet = FALSE; lstrcpy( tcresubops.szPassword, ASTERIX); lstrcpy( tcresubops.szRunAsPassword, ASTERIX); // fill the TCMDPARSER structure TCMDPARSER cmdOptions[] = { { CMDOPTION_CREATE, CP_MAIN_OPTION, OPTION_COUNT, 0, &tcresubops.bCreate, NULL_STRING, NULL, NULL }, { SWITCH_SERVER, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, &tcresubops.szServer, NULL_STRING, NULL, NULL }, { SWITCH_RUNAS_USER, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szRunAsUser, NULL_STRING, NULL, NULL }, { SWITCH_RUNAS_PASSWORD, CP_TYPE_TEXT | CP_VALUE_OPTIONAL, OPTION_COUNT, 0, &tcresubops.szRunAsPassword, NULL_STRING, NULL, NULL }, { SWITCH_USER, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szUser, NULL_STRING, NULL, NULL }, { SWITCH_PASSWORD, CP_TYPE_TEXT | CP_VALUE_OPTIONAL, OPTION_COUNT, 0, &tcresubops.szPassword, NULL_STRING, NULL, NULL }, { SWITCH_SCHEDULETYPE, CP_TYPE_TEXT | CP_VALUE_MANDATORY | CP_MANDATORY, OPTION_COUNT, 0, tcresubops.szSchedType, NULL_STRING, NULL, NULL }, { SWITCH_MODIFIER, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szModifier, NULL_STRING, NULL, NULL }, { SWITCH_DAY, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szDays, NULL_STRING, NULL, NULL }, { SWITCH_MONTHS, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szMonths, NULL_STRING, NULL, NULL }, { SWITCH_IDLETIME, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szIdleTime, NULL_STRING, NULL, NULL }, { SWITCH_TASKNAME, CP_TYPE_TEXT | CP_VALUE_MANDATORY | CP_MANDATORY, OPTION_COUNT, 0, tcresubops.szTaskName, NULL_STRING, NULL, NULL }, { SWITCH_TASKRUN, CP_TYPE_TEXT | CP_VALUE_MANDATORY | CP_MANDATORY, OPTION_COUNT, 0, tcresubops.szTaskRun, NULL_STRING, NULL, NULL }, { SWITCH_STARTTIME, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szStartTime, NULL_STRING, NULL, NULL }, { SWITCH_STARTDATE, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szStartDate, NULL_STRING, NULL, NULL }, { SWITCH_ENDDATE, CP_TYPE_TEXT | CP_VALUE_MANDATORY, OPTION_COUNT, 0, tcresubops.szEndDate, NULL_STRING, NULL, NULL }, { CMDOPTION_USAGE, CP_USAGE , OPTION_COUNT, 0, &tcresubops.bUsage, 0, 0 } }; // Parsing the copy option switches if ( DoParseParam( argc, argv, SIZE_OF_ARRAY(cmdOptions), cmdOptions ) == FALSE ) { //display error message DISPLAY_MESSAGE( stderr, GetResString(IDS_LOGTYPE_ERROR )); DISPLAY_MESSAGE( stderr, GetReason() ); //DISPLAY_MESSAGE(stderr,GetResString(IDS_CREATE_ERR)); return RETVAL_FAIL; } // trim the blank spaces in string values StrTrim(tcresubops.szServer, TRIM_SPACES ); StrTrim(tcresubops.szTaskName, TRIM_SPACES ); StrTrim(tcresubops.szTaskRun, TRIM_SPACES ); StrTrim(tcresubops.szModifier, TRIM_SPACES ); StrTrim(tcresubops.szMonths, TRIM_SPACES ); StrTrim(tcresubops.szUser, TRIM_SPACES ); StrTrim(tcresubops.szRunAsUser, TRIM_SPACES ); StrTrim(tcresubops.szSchedType, TRIM_SPACES ); StrTrim(tcresubops.szEndDate, TRIM_SPACES ); StrTrim(tcresubops.szStartDate, TRIM_SPACES ); StrTrim(tcresubops.szStartTime, TRIM_SPACES ); StrTrim(tcresubops.szIdleTime, TRIM_SPACES ); StrTrim(tcresubops.szDays, TRIM_SPACES ); // check whether password (-p) specified in the command line or not. if ( cmdOptions[OI_PASSWORD].dwActuals == 0 ) { lstrcpy(tcresubops.szPassword, NULL_STRING); } // check whether run as password (-rp) specified in the command line or not. if ( cmdOptions[OI_RUNASPASSWORD].dwActuals == 0 ) { lstrcpy(tcresubops.szRunAsPassword, NULL_STRING); } // Display create usage if user specified -create -? option if( tcresubops.bUsage == TRUE) { DisplayCreateUsage(); return RETVAL_FAIL; } if( ( cmdOptions[OI_SERVER].dwActuals == 1 ) && ( lstrlen( tcresubops.szServer ) == 0 ) ) { DISPLAY_MESSAGE(stderr,GetResString(IDS_NO_SERVER)); return RETVAL_FAIL; } // check for invalid user name if( ( cmdOptions[OI_SERVER].dwActuals == 0 ) && ( cmdOptions[OI_USERNAME].dwActuals == 1 ) ) { DISPLAY_MESSAGE(stderr, GetResString(IDS_CREATE_USER_BUT_NOMACHINE)); return RETVAL_FAIL; } // check for the length of user name if( ( cmdOptions[OI_SERVER].dwActuals == 1 ) && ( cmdOptions[OI_USERNAME].dwActuals == 1 ) && ( lstrlen( tcresubops.szUser ) == 0 ) ) { DISPLAY_MESSAGE(stderr, GetResString(IDS_INVALID_USERNAME)); return RETVAL_FAIL; } //Determine scheduled type if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_MINUTE)) == 0 ) { dwScheduleType = SCHED_TYPE_MINUTE; } else if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_HOUR)) == 0 ) { dwScheduleType = SCHED_TYPE_HOURLY; } else if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_DAILY)) == 0 ) { dwScheduleType = SCHED_TYPE_DAILY; } else if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_WEEK)) == 0 ) { dwScheduleType = SCHED_TYPE_WEEKLY; } else if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_MONTHLY)) == 0 ) { dwScheduleType = SCHED_TYPE_MONTHLY; } else if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_ONCE)) == 0 ) { dwScheduleType = SCHED_TYPE_ONETIME; } else if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_STARTUP)) == 0 ) { dwScheduleType = SCHED_TYPE_ONSTART; } else if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_LOGON)) == 0 ) { dwScheduleType = SCHED_TYPE_ONLOGON; } else if( lstrcmpi(tcresubops.szSchedType,GetResString(IDS_SCHEDTYPE_IDLE)) == 0 ) { dwScheduleType = SCHED_TYPE_ONIDLE; } else { DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_SCHEDTYPE)); return RETVAL_FAIL; } // Assign the scheduled type to the out parameter. *pdwRetScheType = dwScheduleType; // To find whether run as user name is given in the cmd line or not if( ( cmdOptions[1].dwActuals == 1 ) && ( (cmdOptions[2].dwActuals == 0) && (cmdOptions[4].dwActuals == 0) ) ) { *pwUserStatus = OI_SERVER; } else if( (cmdOptions[2].dwActuals == 1) && (cmdOptions[4].dwActuals == 1) ) { *pwUserStatus = OI_RUNANDUSER; } else if( cmdOptions[2].dwActuals == 1 ) { *pwUserStatus = OI_RUNASUSERNAME; } else if ( cmdOptions[4].dwActuals == 1 ) { *pwUserStatus = OI_USERNAME; } // Start validations for the sub-options if( ValidateSuboptVal(tcresubops, tcreoptvals, cmdOptions, dwScheduleType) == RETVAL_FAIL ) { return(RETVAL_FAIL); } return RETVAL_SUCCESS; } /****************************************************************************** Routine Description: This routine splits the input parameters into 2 substrings and returns it. Arguments: [ in ] szInput : Input string. [ in ] szFirstString : First Output string containing the path of the file. [ in ] szSecondString : The second output containing the paramters. Return Value : A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL on failure ******************************************************************************/ DWORD ProcessFilePath(LPTSTR szInput,LPTSTR szFirstString,LPTSTR szSecondString) { _TCHAR *pszTok = NULL ; _TCHAR *pszSep = NULL ; _TCHAR szTmpString[MAX_RES_STRING] = NULL_STRING; _TCHAR szTmpInStr[MAX_RES_STRING] = NULL_STRING; _TCHAR szTmpOutStr[MAX_RES_STRING] = NULL_STRING; _TCHAR szTmpString1[MAX_RES_STRING] = NULL_STRING; DWORD dwCnt = 0 ; DWORD dwLen = 0 ; #ifdef _WIN64 INT64 dwPos ; #else DWORD dwPos ; #endif //checking if the input parameters are NULL and if so // return FAILURE. This condition will not come // but checking for safety sake. if( (szInput == NULL) || (_tcslen(szInput)==0)) { return RETVAL_FAIL ; } _tcscpy(szTmpString,szInput); _tcscpy(szTmpString1,szInput); _tcscpy(szTmpInStr,szInput); // check for first double quote (") if ( szTmpInStr[0] == _T('\"') ) { // trim the first double quote StrTrim( szTmpInStr, _T("\"")); // check for end double quote pszSep = _tcschr(szTmpInStr,_T('\"')) ; // get the position dwPos = pszSep - szTmpInStr + 1; } else { // check for the space pszSep = _tcschr(szTmpInStr,_T(' ')) ; // get the position dwPos = pszSep - szTmpInStr; } if ( pszSep != NULL ) { szTmpInStr[dwPos] = _T('\0'); } else { _tcscpy(szFirstString, szTmpString); _tcscpy(szSecondString,NULL_STRING); return RETVAL_SUCCESS; } // intialize the variable dwCnt = 0 ; // get the length of the string dwLen = _tcslen ( szTmpString ); // check for end of string while ( ( dwPos <= dwLen ) && szTmpString[dwPos++] != _T('\0') ) { szTmpOutStr[dwCnt++] = szTmpString[dwPos]; } // trim the executable and arguments StrTrim( szTmpInStr, _T("\"")); StrTrim( szTmpInStr, _T(" ")); _tcscpy(szFirstString, szTmpInStr); _tcscpy(szSecondString,szTmpOutStr); // return success return RETVAL_SUCCESS; }