windows-xp/Source/XPSP1/NT/admin/cmdline/scheduledtasks/change.cpp

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

	Copyright(c) Microsoft Corporation

	Module Name:

		change.cpp

	Abstract:

		This module changes the parameters of task(s) present in the system 

	Author:

		Venu Gopal Choudary 01-Mar-2001

	Revision History:
	
		Venu Gopal Choudary  01-Mar-2001 : Created it
		

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


//common header files needed for this file
#include "pch.h"
#include "CommonHeaderFiles.h"


// Function declaration for the Usage function.
VOID DisplayChangeUsage();
BOOL GetTheUserName( LPTSTR pszUserName, DWORD dwMaxUserNameSize );

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

	Routine Description:

	This routine  Changes the paraemters of a specified scheduled task(s)

	Arguments:

		[ in ] argc :  Number of command line arguments
		[ in ] argv :  Array containing command line arguments

	Return Value :
		A DWORD value indicating EXIT_SUCCESS on success else 
		EXIT_FAILURE on failure
  
*****************************************************************************/

DWORD
ChangeScheduledTaskParams(  DWORD argc, LPCTSTR argv[] )
{
	// Variables used to find whether Change option, Usage option
	// are specified or not
	BOOL bChange = FALSE;
	BOOL bUsage = FALSE;

	// Set the TaskSchduler object as NULL
	ITaskScheduler *pITaskScheduler = NULL;
 
	// Return value
	HRESULT hr  = S_OK;
	
	// Initialising the variables that are passed to TCMDPARSER structure
	_TCHAR	szServer[ MAX_STRING_LENGTH ]   = NULL_STRING; 
    _TCHAR	szTaskName[ MAX_STRING_LENGTH ] = NULL_STRING;
    _TCHAR	szTaskRun[ MAX_STRING_LENGTH ] = NULL_STRING;
	_TCHAR	szUserName[MAX_STRING_LENGTH] = NULL_STRING;
	_TCHAR	szPassword[MAX_STRING_LENGTH] = NULL_STRING;
	_TCHAR	szRunAsUserName[MAX_STRING_LENGTH] = NULL_STRING;
	_TCHAR	szRunAsPassword[MAX_STRING_LENGTH] = NULL_STRING;


	// Declarations related to Task name
	WCHAR	wszJobName[MAX_TASKNAME_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;

	// Dynamic Array contaning array of jobs
	TARRAY arrJobs = NULL;

	// Loop Variable.
	DWORD dwJobCount = 0;

	//buffer for displaying error message
	TCHAR	szMessage[MAX_STRING_LENGTH] = NULL_STRING;
	BOOL bUserName = TRUE;
	BOOL bPassWord = TRUE;
	BOOL bSystemStatus = FALSE;
	BOOL  bNeedPassword = FALSE;
	BOOL  bResult = FALSE;
	BOOL  bCloseConnection = TRUE;

	lstrcpy( szPassword, ASTERIX);
	lstrcpy( szRunAsPassword, ASTERIX);

	// Builiding the TCMDPARSER structure
	TCMDPARSER cmdOptions[] = 
	{
		{ 
		  CMDOPTION_CHANGE,
		  CP_MAIN_OPTION,
		  1,
		  0,
		  &bChange,
		  NULL_STRING,
		  NULL,
		  NULL
		},
		{ 
		  SWITCH_SERVER,
		  CP_TYPE_TEXT | CP_VALUE_MANDATORY, 
		  1,
		  0,
		  &szServer,
		  NULL_STRING,
		  NULL, 
		  NULL
		},
		{ 
			SWITCH_USER,
			CP_TYPE_TEXT | CP_VALUE_MANDATORY,
			OPTION_COUNT,
			0,
			&szUserName,
			NULL_STRING,
			NULL,
			NULL
		},
		{ 
			SWITCH_PASSWORD,
			CP_TYPE_TEXT | CP_VALUE_OPTIONAL,
			OPTION_COUNT,
			0,
			&szPassword,
			NULL_STRING,
			NULL,
			NULL
		},
		{ 
			SWITCH_RUNAS_USER,
			CP_TYPE_TEXT | CP_VALUE_MANDATORY,
			OPTION_COUNT,
			0,
			&szRunAsUserName,
			NULL_STRING,
			NULL,
			NULL
		},
		{ 
			SWITCH_RUNAS_PASSWORD,
			CP_TYPE_TEXT | CP_VALUE_OPTIONAL,
			OPTION_COUNT,
			0,
			&szRunAsPassword,
			NULL_STRING,
			NULL,
			NULL
		},
		{ 
		  SWITCH_TASKNAME,
		  CP_TYPE_TEXT | CP_VALUE_MANDATORY | CP_MANDATORY ,
		  1,
		  0,
		  &szTaskName,
		  NULL_STRING,
		  NULL,
		  NULL
		},
		{ 
		  SWITCH_TASKRUN,
		  CP_TYPE_TEXT | CP_VALUE_MANDATORY,
		  1,
		  0,
		  &szTaskRun,
		  NULL_STRING,
		  NULL,
		  NULL
		},
		{ 
		  CMDOPTION_USAGE,
		  CP_USAGE ,
		  1,
		  0, 
		  &bUsage,
		  NULL_STRING, 
		  NULL, 
		  NULL
		 }
	};	
	
	// Parsing the change option switches
	if ( DoParseParam( argc, argv, SIZE_OF_ARRAY(cmdOptions), cmdOptions ) == FALSE)
	{
		DISPLAY_MESSAGE( stderr, GetResString(IDS_LOGTYPE_ERROR ));
		DISPLAY_MESSAGE( stderr, GetReason() );
		return EXIT_FAILURE;
	}

	// triming the null spaces
	StrTrim(szServer, TRIM_SPACES );
	StrTrim(szUserName, TRIM_SPACES );
	StrTrim(szTaskName, TRIM_SPACES );
	StrTrim(szRunAsUserName, TRIM_SPACES );
	StrTrim(szTaskRun, TRIM_SPACES );

	// check whether password (-p) specified in the command line or not.
	if ( cmdOptions[OI_CHPASSWORD].dwActuals == 0 )
	{
		lstrcpy( szPassword, NULL_STRING );
	}

	// check whether run as password (-rp) specified in the command line or not.
	if ( cmdOptions[OI_CHRUNASPASSWORD].dwActuals == 0 )
	{
		lstrcpy( szRunAsPassword, NULL_STRING );
	}

	// Displaying change usage if user specified -? with -change option
	if( bUsage == TRUE )
	{
		DisplayChangeUsage();
		return EXIT_SUCCESS;
	}

	// check for -s, -ru, -rp or -tr options specified in the cmdline or not
	if( ( cmdOptions[OI_CHSERVER].dwActuals == 0 ) &&  
		( cmdOptions[OI_CHRUNASUSER].dwActuals == 0 ) &&
		( cmdOptions[OI_CHRUNASPASSWORD].dwActuals == 0 ) &&
		( cmdOptions[OI_CHTASKRUN].dwActuals == 0 ) )
	{
		DISPLAY_MESSAGE(stderr,GetResString(IDS_NO_CHANGE_OPTIONS));	
		return RETVAL_FAIL;
	}

	// check for invalid server
	if( ( cmdOptions[OI_CHSERVER].dwActuals == 1 ) &&  ( lstrlen( szServer ) == 0 ) )
	{
		DISPLAY_MESSAGE(stderr, GetResString(IDS_NO_SERVER));	
		return RETVAL_FAIL;
	}

	// check whether -u or -ru options specified respectively with -p or -rp options or not
	if ( cmdOptions[ OI_CHUSERNAME ].dwActuals == 0 && cmdOptions[ OI_CHPASSWORD ].dwActuals == 1 ) 
	{
		// invalid syntax
		DISPLAY_MESSAGE(stderr, GetResString(IDS_CHPASSWORD_BUT_NOUSERNAME));
		return RETVAL_FAIL;			// indicate failure
	}


	// check for invalid user name
	if( ( cmdOptions[OI_CHSERVER].dwActuals == 0 ) && ( cmdOptions[OI_CHUSERNAME].dwActuals == 1 )  )
	{
		DISPLAY_MESSAGE(stderr, GetResString(IDS_CHANGE_USER_BUT_NOMACHINE));	
		return RETVAL_FAIL;
	}
	
	// check for the length of user name
	if( ( cmdOptions[OI_CHSERVER].dwActuals == 1 ) && ( cmdOptions[OI_CHUSERNAME].dwActuals == 1 ) &&
					( lstrlen( szUserName ) == 0 ) )
	{
		DISPLAY_MESSAGE(stderr, GetResString(IDS_INVALID_USERNAME));	
		return RETVAL_FAIL;
	}

	// check for the length of username
	if( ( lstrlen( szUserName ) > MAX_USERNAME_LENGTH ) ||
			( lstrlen( szRunAsUserName ) > MAX_USERNAME_LENGTH ) )
	{
		DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_UNAME));
		return RETVAL_FAIL;
	}

	// check for the length of password
	if(	( lstrlen( szRunAsPassword ) > MAX_PASSWORD_LENGTH ) ||
		( lstrlen( szPassword ) > MAX_PASSWORD_LENGTH ) )
	{
		DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD));
		return RETVAL_FAIL;
	}

	// check for the length of taskname
	if( ( lstrlen( szTaskName ) > MAX_JOB_LEN ) || ( lstrlen(szTaskName) == 0 ) )
	{
		DISPLAY_MESSAGE( stderr, GetResString(IDS_INVALID_TASKLENGTH) );
		return RETVAL_FAIL;
	}
		
	// check for the length of task to run
	if( ( cmdOptions[OI_CHTASKRUN].dwActuals == 1 ) && 
		( ( lstrlen( szTaskRun ) > MAX_TASK_LEN ) ||
		( lstrlen ( szTaskRun ) == 0 ) ) )
	{
		DISPLAY_MESSAGE(stderr, GetResString(IDS_INVALID_TASKRUN));	
		return RETVAL_FAIL;
	}

	// Convert the task name specified by the user to wide char or unicode format
	if( GetAsUnicodeString(szTaskName,wszJobName,SIZE_OF_ARRAY(wszJobName)) == NULL )
	{
		return RETVAL_FAIL;
	}
	
	//for holding values of parameters in FormatMessage()
	_TCHAR* szValues[1] = {NULL};
	BOOL bLocalMachine = FALSE;
	BOOL bRemoteMachine = FALSE;

#ifdef _WIN64
	INT64 dwPos = 0;
#else
	DWORD dwPos = 0;
#endif

    // check whether remote machine specified or not
	if( cmdOptions[OI_CHSERVER].dwActuals == 1 )
	{
		bRemoteMachine = TRUE;
	}
	else
	{
		bLocalMachine = TRUE;	
	}

	// check whether the password (-p) specified in the command line or not 
	// and also check whether '*' or empty is given for -p or not
	if( ( IsLocalSystem( szServer ) == FALSE ) && 
		( ( cmdOptions[OI_CHPASSWORD].dwActuals == 0 ) || ( lstrcmpi ( szPassword, ASTERIX ) == 0 ) ) )
	{
		bNeedPassword = TRUE;
	}
	
	// check whether server (-s) and username (-u) only specified along with the command or not
	if( ( IsLocalSystem( szServer ) == FALSE ) || ( cmdOptions[OI_CHUSERNAME].dwActuals == 1 ) )
	{
		// Establish the connection on a remote machine
		bResult = EstablishConnection(szServer,szUserName,SIZE_OF_ARRAY(szUserName),szPassword,SIZE_OF_ARRAY(szPassword), bNeedPassword );
		if (bResult == FALSE)
		{
			// displays the appropriate error message
			DISPLAY_MESSAGE( stderr, GetResString(IDS_ERROR_STRING) );
			DISPLAY_MESSAGE( stderr, GetReason());
			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());
					return EXIT_FAILURE;
				}
			}
		}
	
	}

	// Get the task Scheduler object for the system.
	pITaskScheduler = GetTaskScheduler( 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( szServer );

		Cleanup(pITaskScheduler);
		return EXIT_FAILURE;
    }

	// Validate the Given Task and get as TARRAY in case of taskname 
	arrJobs = ValidateAndGetTasks( pITaskScheduler, szTaskName);
	if( arrJobs == NULL )
	{
		_stprintf( szMessage , GetResString(IDS_TASKNAME_NOTEXIST), szTaskName);	
		DISPLAY_MESSAGE(stderr,szMessage);	

		// close the connection that was established by the utility
		if ( bCloseConnection == TRUE )
			CloseConnection( szServer );

		Cleanup(pITaskScheduler);
		return EXIT_FAILURE;
		
	}

	IPersistFile *pIPF = NULL;
    ITask *pITask = NULL;

	// returns an pITask inteface for wszJobName
	hr = pITaskScheduler->Activate(wszJobName,IID_ITask,
									   (IUnknown**) &pITask);
 
	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( szServer );

		Cleanup(pITaskScheduler);
		
		return EXIT_FAILURE;
    }

	//if the user name is not specifed set the current logged on user settings 
	DWORD dwUserLen = MAX_USERNAME_LEN;
	DWORD dwResult = 0;
	BOOL  bFlag = FALSE;
	ULONG ulLong = MAX_RES_STRING;
	TCHAR szBuffer[MAX_STRING_LENGTH] = NULL_STRING;
	TCHAR szRunAsUser[MAX_STRING_LENGTH] = NULL_STRING;

	// declaration for parameter arguments
	wchar_t* wcszParam = L"";

	// get the run as user name for a specified scheduled task
	hr = GetRunAsUser(pITask, szRunAsUser);
	
	if ( ( cmdOptions[OI_CHRUNASUSER].dwActuals == 1 ) && 
		( (lstrlen( szRunAsUserName) == 0) || ( lstrcmpi(szRunAsUserName, NTAUTHORITY_USER ) == 0 ) ||
		(lstrcmpi(szRunAsUserName, SYSTEM_USER ) == 0 ) ) )
	{
		bSystemStatus = TRUE;
		bFlag = TRUE;
	}
	else if ( FAILED (hr) )
	{
		bFlag = TRUE;
	}

	// flag to check whether run as user name is "NT AUTHORITY\SYSTEM" or not
	if ( bFlag == FALSE )
	{
		// check for "NT AUTHORITY\SYSTEM" username
		if( ( ( cmdOptions[OI_CHRUNASUSER].dwActuals == 1 ) && ( lstrlen( szRunAsUserName) == 0 ) ) || 
		( ( cmdOptions[OI_CHRUNASUSER].dwActuals == 1 ) && ( lstrlen( szRunAsUserName) == 0 ) && ( lstrlen(szRunAsPassword ) == 0 ) ) ||
		( ( cmdOptions[OI_CHRUNASUSER].dwActuals == 1 ) && ( lstrcmpi(szRunAsUserName, NTAUTHORITY_USER ) == 0 ) && ( lstrlen(szRunAsPassword ) == 0 )) ||
		( ( cmdOptions[OI_CHRUNASUSER].dwActuals == 1 ) && ( lstrcmpi(szRunAsUserName, NTAUTHORITY_USER ) == 0 ) ) ||
		( ( cmdOptions[OI_CHRUNASUSER].dwActuals == 1 ) && ( lstrcmpi(szRunAsUserName, SYSTEM_USER) == 0 ) && ( lstrlen(szRunAsPassword ) == 0 ) ) ||
		( ( cmdOptions[OI_CHRUNASUSER].dwActuals == 1 ) && ( lstrcmpi(szRunAsUserName, SYSTEM_USER ) == 0 ) ) )
		{
			bSystemStatus = TRUE;
		}
	}

	if ( bSystemStatus == FALSE )
	{
		//check the length of run as user name	
		if ( (lstrlen( szRunAsUserName ) != 0 ))
		{
			// Convert the run as user name specified by the user to wide char or unicode format
			if ( GetAsUnicodeString(szRunAsUserName, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL )
			{
				// close the connection that was established by the utility
				if ( bCloseConnection == TRUE )
					CloseConnection( szServer );

				return EXIT_FAILURE;
			}
		}
		else
		{
			bUserName = FALSE;	
		}

		//check for the null password	
		if ( ( lstrlen( szRunAsPassword ) != 0 ) && ( lstrcmpi ( szRunAsPassword, ASTERIX) != 0 ) )
		{
			// Convert the password specified by the user to wide char or unicode format
			if ( GetAsUnicodeString( szRunAsPassword, wszPassword, SIZE_OF_ARRAY(wszPassword)) == NULL )
			{
				// close the connection that was established by the utility
				if ( bCloseConnection == TRUE )
					CloseConnection( szServer );

				return EXIT_FAILURE;
			}

			bPassWord = TRUE;
		}
		else
		{
			// check whether -rp is specified or not
			if (cmdOptions[OI_CHRUNASPASSWORD].dwActuals == 1)
			{
				if( ( lstrcmpi( szRunAsPassword , NULL_STRING ) != 0 ) && ( lstrcmpi ( szRunAsPassword, ASTERIX) != 0 ) )
				{
					bPassWord = TRUE;
				}
				else if ( ( bSystemStatus == FALSE ) && ( lstrlen (szRunAsPassword) == 0 ) )
				{
					DISPLAY_MESSAGE (stderr, GetResString(IDS_NO_PASSWORD));
					
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					Cleanup(pITaskScheduler);
					return EXIT_FAILURE;
				}
				else if ( lstrcmpi ( szRunAsPassword, ASTERIX) == 0 )
				{
					bPassWord = FALSE;
				}
			}	
			else if ( bSystemStatus == FALSE )
			{
				bPassWord = FALSE;
			}
		
		}
	}

	// check for the status of username and password
	if( ( bUserName == TRUE ) && ( bPassWord == FALSE ) )
	{
		// check for the local or remote system
		if ( (bLocalMachine == TRUE) || (bRemoteMachine == TRUE) )   
		{
			szValues[0] = (_TCHAR*) (szRunAsUserName);
			FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
					  GetResString(IDS_PROMPT_CHGPASSWD),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( szRunAsPassword, MAX_PASSWORD_LENGTH ) == FALSE )
			{
				// close the connection that was established by the utility
				if ( bCloseConnection == TRUE )
					CloseConnection( szServer );

				return EXIT_FAILURE;
			}

			// check for the length of password
			if( lstrlen(szRunAsPassword) > MAX_PASSWORD_LENGTH )
			{
				DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD));
				Cleanup(pITaskScheduler);
				return E_FAIL;
			}

			//check for the null password
			if( lstrcmpi( szRunAsPassword , NULL_STRING ) == 0 )
			{
				DISPLAY_MESSAGE (stderr, GetResString(IDS_NO_PASSWORD));
				if( pIPF )
					pIPF->Release();

				if( pITask )
					pITask->Release();
			
				// close the connection that was established by the utility
				if ( bCloseConnection == TRUE )
					CloseConnection( szServer );

				Cleanup(pITaskScheduler);
		
				return EXIT_FAILURE;
			}

			// check for the password length > 0
			if(lstrlen( szRunAsPassword ))
			{
				// Convert the password specified by the user to wide char or unicode format
				if ( GetAsUnicodeString( szRunAsPassword, wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL )
				{
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}
			}
		}
				
	}
	// check for the status of user name and password
	else if( ( bUserName == FALSE ) && ( bPassWord == TRUE ) )
	{	
		if ( (bLocalMachine == TRUE) || (bRemoteMachine == TRUE) )  
		{
	
			if ( (bFlag == TRUE ) && ( bSystemStatus == FALSE ) )
			{
				DISPLAY_MESSAGE(stdout, GetResString(IDS_PROMPT_USERNAME));
				
				if ( GetTheUserName( szRunAsUserName, MAX_USERNAME_LENGTH) == FALSE )
				{
					DISPLAY_MESSAGE(stderr, GetResString( IDS_FAILED_TOGET_USER ) );
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}

				// check for the length of username
				if( lstrlen(szRunAsUserName) > MAX_USERNAME_LENGTH ) 
				{
					DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_UNAME  ));
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}

				if ( (lstrlen( szRunAsUserName) == 0) || ( lstrcmpi(szRunAsUserName, NTAUTHORITY_USER ) == 0 ) ||
					(lstrcmpi(szRunAsUserName, SYSTEM_USER ) == 0 ) )
				{
					bSystemStatus = TRUE;
					bFlag = TRUE;
				}
				else
				{
					// check for the length of run as user name
					if(lstrlen(szRunAsUserName))
					{
						// Convert the run as user name specified by the user to wide char or unicode format
						if (GetAsUnicodeString(szRunAsUserName, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL )
						{
							// close the connection that was established by the utility
							if ( bCloseConnection == TRUE )
								CloseConnection( szServer );

							return EXIT_FAILURE;
						}
					}
				}
			
			}
			else
			{
				// Convert the run as user name specified by the user to wide char or unicode format
				if (GetAsUnicodeString( szRunAsUser, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL )
				{
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}
			}
	
			// check for the length of password > 0			
			if(lstrlen(szRunAsPassword))
			{
				// Convert the password specified by the user to wide char or unicode format
				if (GetAsUnicodeString(szRunAsPassword, wszPassword, SIZE_OF_ARRAY(wszPassword)) == NULL )
				{
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}
			}
		}
					
	}
	// check for the user name and password are not specified
	else if( ( bUserName == FALSE ) && ( bPassWord == FALSE ) )
	{	
		if ( (bLocalMachine == TRUE) || (bRemoteMachine == TRUE) )  
		{
			if ( (bFlag == TRUE ) && ( bSystemStatus == FALSE ) )
			{
				DISPLAY_MESSAGE(stdout, GetResString(IDS_PROMPT_USERNAME));
				
				if ( GetTheUserName( szRunAsUserName, MAX_USERNAME_LENGTH ) == FALSE )
				{
					DISPLAY_MESSAGE(stderr, GetResString( IDS_FAILED_TOGET_USER ) );
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}

				// check for the length of username
				if( lstrlen(szRunAsUserName) > MAX_USERNAME_LENGTH ) 
				{
					DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_UNAME  ));
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}

				if ( (lstrlen( szRunAsUserName) == 0) || ( lstrcmpi(szRunAsUserName, NTAUTHORITY_USER ) == 0 ) ||
					(lstrcmpi(szRunAsUserName, SYSTEM_USER ) == 0 ) )
				{
					bSystemStatus = TRUE;
					bFlag = TRUE;
				}
				else
				{
					if(lstrlen(szRunAsUserName))
					{
						// Convert the run as user name specified by the user to wide char or unicode format
						if ( GetAsUnicodeString(szRunAsUserName, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL )
						{
							// close the connection that was established by the utility
							if ( bCloseConnection == TRUE )
								CloseConnection( szServer );

							return EXIT_FAILURE;
						}
					}
				}
				
			}
			else 
			{
				// Convert the run as user name specified by the user to wide char or unicode format
				if (GetAsUnicodeString( szRunAsUser, wszUserName, SIZE_OF_ARRAY(wszUserName)) == NULL )
				{
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}
			}

			if ( wcslen ( wszUserName ) != 0 )
			{
				szValues[0] = (_TCHAR*) (wszUserName);
			
				FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
				  GetResString(IDS_PROMPT_CHGPASSWD),0,MAKELANGID(LANG_NEUTRAL,
						  SUBLANG_DEFAULT),szBuffer,
						  MAX_STRING_LENGTH,(va_list*)szValues );

				DISPLAY_MESSAGE(stdout,szBuffer);
				
				// Get the run as user password from the command line
				if ( GetPassword( szRunAsPassword, MAX_PASSWORD_LENGTH ) == FALSE )
				{
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					return EXIT_FAILURE;
				}

				// check for the length of password
				if( lstrlen(szRunAsPassword) > MAX_PASSWORD_LENGTH )
				{
					DISPLAY_MESSAGE(stderr,GetResString(IDS_INVALID_PASSWORD));
					Cleanup(pITaskScheduler);
					return E_FAIL;
				}

				//check for the null password
				if( lstrcmpi( szRunAsPassword , NULL_STRING ) == 0 )
				{
					DISPLAY_MESSAGE (stderr, GetResString(IDS_NO_PASSWORD));
					if( pIPF )
						pIPF->Release();

					if( pITask )
						pITask->Release();
				
					// close the connection that was established by the utility
					if ( bCloseConnection == TRUE )
						CloseConnection( szServer );

					Cleanup(pITaskScheduler);
			
					return EXIT_FAILURE;
				}
				
				if(lstrlen( szRunAsPassword ))
				{
					// Convert the password specified by the user to wide char or unicode format
					if (GetAsUnicodeString( szRunAsPassword, wszPassword,SIZE_OF_ARRAY(wszPassword)) == NULL )
					{
						// close the connection that was established by the utility
						if ( bCloseConnection == TRUE )
							CloseConnection( szServer );

						return EXIT_FAILURE;
					}
				}
			}
		
		}
					
	}
 
	// 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( szServer );

		Cleanup(pITaskScheduler);
		
		return EXIT_FAILURE;
    }
    
	if( cmdOptions[OI_CHTASKRUN].dwActuals == 0 )
	{
		LPWSTR lpwszApplicationName = NULL;
		LPWSTR lpwszParams =  NULL;

		// get the application name
		hr = pITask->GetApplicationName(&lpwszApplicationName);
		if (FAILED(hr))
		{
			DisplayErrorMsg(hr);

			if( pIPF )
				pIPF->Release();

			if( pITask )
				pITask->Release();
			
			CoTaskMemFree( lpwszApplicationName );
			
			// close the connection that was established by the utility
			if ( bCloseConnection == TRUE )
				CloseConnection( szServer );

			Cleanup(pITaskScheduler);
			return EXIT_FAILURE;
		}

		// get the parameters
		hr = pITask->GetParameters(&lpwszParams);
		if (FAILED(hr))
		{
			DisplayErrorMsg(hr);

			if( pIPF )
				pIPF->Release();

			if( pITask )
				pITask->Release();
			
			CoTaskMemFree( lpwszParams );
			
			// close the connection that was established by the utility
			if ( bCloseConnection == TRUE )
				CloseConnection( szServer );

			Cleanup(pITaskScheduler);
			return EXIT_FAILURE;
		}

		lstrcpy(wszCommand,lpwszApplicationName);
		CoTaskMemFree( lpwszApplicationName );

		// set the task to run application name
		hr = pITask->SetApplicationName(wszCommand);
		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( szServer );

		Cleanup(pITaskScheduler);
        return EXIT_FAILURE;
		}
	
		lstrcpy(wszCommand,lpwszParams);
		CoTaskMemFree( lpwszParams );

		// set the task to run application name
		hr = pITask->SetParameters(wszCommand);
		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( szServer );

			Cleanup(pITaskScheduler);
			return EXIT_FAILURE;
		}

	} 
	else
	{
		// Convert the task to run specified by the user to wide char or unicode format
		if ( GetAsUnicodeString(szTaskRun,wszCommand,SIZE_OF_ARRAY(wszCommand)) == NULL )
		{
			// close the connection that was established by the utility
			if ( bCloseConnection == TRUE )
				CloseConnection( szServer );

			return EXIT_FAILURE;
		}
    
		// check for .exe substring string in the given task to run string
		
		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( szServer );

			Cleanup(pITaskScheduler);
			return EXIT_FAILURE;

		}
	
		
		// 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( szServer );

			Cleanup(pITaskScheduler);
			return EXIT_FAILURE;
		}
	
	
		//[Working directory =  exe pathname - exe name] 
		wchar_t* wcszStartIn = wcsrchr(wszApplName,_T('\\'));
		if(wcszStartIn != NULL)
			*( wcszStartIn ) = _T('\0');
		
		// set the working directory of command
		hr = pITask->SetWorkingDirectory(wszApplName); 

		if (FAILED(hr))
		{
			DisplayErrorMsg(hr);

			if( pIPF )
				pIPF->Release();

			if( pITask )
				pITask->Release();
				
			// close the connection that was established by the utility
			if ( bCloseConnection == TRUE )
				CloseConnection( szServer );

			Cleanup(pITaskScheduler);
			return EXIT_FAILURE;
		}

		// 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( szServer );

			Cleanup(pITaskScheduler);
			return EXIT_FAILURE;
		}
	}

	if( bSystemStatus == TRUE )
	{
		// Change the account information to "NT AUTHORITY\SYSTEM" user
		hr = pITask->SetAccountInformation(L"",NULL);	
		if ( FAILED(hr) )
		{
			DISPLAY_MESSAGE(stderr, GetResString(IDS_NTAUTH_SYSTEM_ERROR));
			
			if( pIPF )
				pIPF->Release();

			if( pITask )
				pITask->Release();
			
			// close the connection that was established by the utility
			if ( bCloseConnection == TRUE )
				CloseConnection( szServer );

			Cleanup(pITaskScheduler);
			return EXIT_FAILURE;
		}
	}
	else
	{
		// set the account information with the user name and password
		hr = pITask->SetAccountInformation(wszUserName,wszPassword);
	}
	
    if ((FAILED(hr)) && (hr != SCHED_E_NO_SECURITY_SERVICES))
    {
		DisplayErrorMsg(hr);
	
		if( pIPF )
			pIPF->Release();

		if( pITask )
			pITask->Release();
			
		// close the connection that was established by the utility
		if ( bCloseConnection == TRUE )
			CloseConnection( szServer );

		Cleanup(pITaskScheduler);
	    return EXIT_FAILURE;
    }
	
	if ( bSystemStatus == TRUE )
	{
		szValues[0] = (_TCHAR*) (wszJobName);
		FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
					  GetResString(IDS_NTAUTH_SYSTEM_CHANGE_INFO),0,MAKELANGID(LANG_NEUTRAL,
				      SUBLANG_DEFAULT),szBuffer,
				      MAX_STRING_LENGTH,(va_list*)szValues
				     );
			
		DISPLAY_MESSAGE(stdout,szBuffer);
	}
	
	if( (cmdOptions[OI_CHRUNASPASSWORD].dwActuals == 1) && ( bSystemStatus == TRUE ) &&
			(lstrlen( szRunAsPassword ) != 0) )
	{
		DISPLAY_MESSAGE( stdout, GetResString( IDS_PASSWORD_NOEFFECT ) ); 
	}

	// save the copy of an object
	hr = pIPF->Save(NULL,TRUE);

    if( E_FAIL == hr )
    {
		DisplayErrorMsg(hr);
		if(pIPF)
			pIPF->Release();

		if(pITask)
			pITask->Release();
		
		// close the connection that was established by the utility
		if ( bCloseConnection == TRUE )
			CloseConnection( szServer );

		Cleanup(pITaskScheduler);
        return EXIT_FAILURE;
    }

	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( szServer );

		Cleanup(pITaskScheduler);
        return EXIT_FAILURE;
	}
	else
	{
		// to display a success message
		szValues[0] = (_TCHAR*) (wszJobName);
		FormatMessage(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
					  GetResString(IDS_CHANGE_SUCCESSFUL),0,MAKELANGID(LANG_NEUTRAL,
				      SUBLANG_DEFAULT),szBuffer,
				      MAX_STRING_LENGTH,(va_list*)szValues
				     );
			
		DISPLAY_MESSAGE(stdout,szBuffer);
		
	}

	if( pIPF )
		pIPF->Release();

	if( pITask )
		pITask->Release();
			
	// close the connection that was established by the utility
	if ( bCloseConnection == TRUE )
		CloseConnection( szServer );

	Cleanup(pITaskScheduler);

	return EXIT_SUCCESS;
}

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

	Routine Description:

		This routine  displays the usage of -change option

	Arguments:
		None

	Return Value :
		VOID
******************************************************************************/

VOID
DisplayChangeUsage()
{
	// Displaying -change option usage
	DisplayUsage( IDS_CHANGE_HLP1, IDS_CHANGE_HLP33 );
}

// ***************************************************************************
// Routine Description:
//
// Takes the user name from the keyboard.While entering the user name 
//  it displays the user name as it is.
//
// Arguments:
//
// [in] pszUserName		    -- String to store user name
// [in] dwMaxUserNameSize	-- Maximun size of the user name. 
//  
// Return Value:
//
// BOOL				--If this function succeds returns TRUE otherwise returns FALSE.
// 
// ***************************************************************************
BOOL GetTheUserName( LPTSTR pszUserName, DWORD dwMaxUserNameSize )
{
	// local variables
	TCHAR ch;
	DWORD dwIndex = 0;
	DWORD dwCharsRead = 0;
	DWORD dwCharsWritten = 0;
	DWORD dwPrevConsoleMode = 0;
	HANDLE hInputConsole = NULL;
	TCHAR szBuffer[ 10 ] = NULL_STRING;		


	// check the input value
	if ( pszUserName == NULL )
	{
		SetLastError( ERROR_INVALID_PARAMETER );
		SaveLastError();
		return FALSE;
	}
	
	// Get the handle for the standard input
	hInputConsole = GetStdHandle( STD_INPUT_HANDLE );
	if ( hInputConsole == NULL )
	{
		// could not get the handle so return failure
		return FALSE;
	}

	// Get the current input mode of the input buffer
	GetConsoleMode( hInputConsole, &dwPrevConsoleMode );
	
	// Set the mode such that the control keys are processed by the system
	if ( SetConsoleMode( hInputConsole, ENABLE_PROCESSED_INPUT ) == 0 )
	{
		// could not set the mode, return failure
		return FALSE;
	}
	
	//	Read the characters until a carriage return is hit
	while( TRUE )
	{
		
		if ( ReadConsole( hInputConsole, &ch, 1, &dwCharsRead, NULL ) == 0 )
		{
			// Set the original console settings
			SetConsoleMode( hInputConsole, dwPrevConsoleMode );
			
			// return failure
			return FALSE;
		}
		
		// Check for carraige return
		if ( ch == CARRIAGE_RETURN )
		{
			DISPLAY_MESSAGE(stdout, _T("\n"));
			// break from the loop
			break;
		}

			// Check id back space is hit
		if ( ch == BACK_SPACE )
		{
			if ( dwIndex != 0 )
			{
				//
				// Remove a asterix from the console

				// move the cursor one character back
				FORMAT_STRING( szBuffer, _T( "%c" ), BACK_SPACE );
				WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), szBuffer, 1, 
					&dwCharsWritten, NULL );
				
				// replace the existing character with space
				FORMAT_STRING( szBuffer, _T( "%c" ), BLANK_CHAR );
				WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), szBuffer, 1, 
					&dwCharsWritten, NULL );

				// now set the cursor at back position
				FORMAT_STRING( szBuffer, _T( "%c" ), BACK_SPACE );
				WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), szBuffer, 1, 
					&dwCharsWritten, NULL );

				// decrement the index 
				dwIndex--;
			}
			
			// process the next character
			continue;
		}

		// if the max user name length has been reached then sound a beep
		if ( dwIndex == ( dwMaxUserNameSize - 1 ) )
		{
			WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), BEEP_SOUND, 1, 
				&dwCharsRead, NULL );
		}
		else
		{
			// store the input character
			*( pszUserName + dwIndex ) = ch;
				
			// display asterix onto the console
			WriteConsole( GetStdHandle( STD_OUTPUT_HANDLE ), ( pszUserName + dwIndex ) , 1, 
				&dwCharsWritten, NULL );

			dwIndex++;

		}
	}

	// Add the NULL terminator
	*( pszUserName + dwIndex ) = NULL_CHAR;

	//	Return success
	return TRUE;
}