2542 lines
71 KiB
C++
2542 lines
71 KiB
C++
/******************************************************************************
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
|