2479 lines
75 KiB
C++
2479 lines
75 KiB
C++
/******************************************************************************
|
|
|
|
Copyright(c) Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
CreateValidations.cpp
|
|
|
|
Abstract:
|
|
|
|
This module validates the various -create sub options specified by the user
|
|
|
|
Author:
|
|
|
|
B.Raghu babu 20-Sept-2000 : Created
|
|
|
|
Revision History:
|
|
|
|
G.Surender Reddy 25-sep-2000 : Modified it
|
|
[ Added error checking ]
|
|
|
|
G.Surender Reddy 10-Oct-2000 : Modified it
|
|
[ made changes in validatemodifierval(),
|
|
ValidateDayAndMonth() functions ]
|
|
|
|
|
|
G.Surender Reddy 15-oct-2000 : Modified it
|
|
[ Moved the strings to Resource table ]
|
|
|
|
Venu Gopal S 26-Feb-2001 : Modified it
|
|
[ Added GetDateFormatString(),
|
|
GetDateFieldFormat() functions to
|
|
gets the date format according to
|
|
regional options]
|
|
|
|
******************************************************************************/
|
|
|
|
//common header files needed for this file
|
|
#include "pch.h"
|
|
#include "CommonHeaderFiles.h"
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the sub options specified by the user reg.create option
|
|
& determines the type of a scheduled task.
|
|
|
|
Arguments:
|
|
|
|
[ out ] tcresubops : Structure containing the task's properties
|
|
[ out ] tcreoptvals : Structure containing optional values to set
|
|
[ in ] cmdOptions[] : Array of type TCMDPARSER
|
|
[ in ] dwScheduleType : Type of schedule[Daily,once,weekly etc]
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL
|
|
on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateSuboptVal(
|
|
OUT TCREATESUBOPTS& tcresubops,
|
|
OUT TCREATEOPVALS &tcreoptvals,
|
|
IN TCMDPARSER2 cmdOptions[],
|
|
IN DWORD dwScheduleType
|
|
)
|
|
{
|
|
DWORD dwRetval = RETVAL_SUCCESS;
|
|
BOOL bIsStDtCurDt = FALSE;
|
|
BOOL bIsStTimeCurTime = FALSE;
|
|
BOOL bIsDefltValMod = FALSE;
|
|
|
|
// Validate whether -s, -u, -p options specified correctly or not.
|
|
//Accept password if -p not specified.
|
|
dwRetval = ValidateRemoteSysInfo( cmdOptions, tcresubops, tcreoptvals);
|
|
if(RETVAL_FAIL == dwRetval )
|
|
{
|
|
return dwRetval; // Error.
|
|
}
|
|
|
|
// Validate Modifier value.
|
|
dwRetval = ValidateModifierVal( tcresubops.szModifier, dwScheduleType,
|
|
cmdOptions[OI_CREATE_MODIFIER].dwActuals,
|
|
cmdOptions[OI_CREATE_DAY].dwActuals,
|
|
cmdOptions[OI_CREATE_MONTHS].dwActuals,
|
|
bIsDefltValMod);
|
|
if(RETVAL_FAIL == dwRetval )
|
|
{
|
|
|
|
return dwRetval; // error in modifier value
|
|
}
|
|
else
|
|
{
|
|
if(bIsDefltValMod)
|
|
{
|
|
StringCopy(tcresubops.szModifier,DEFAULT_MODIFIER_SZ, SIZE_OF_ARRAY(tcresubops.szModifier));
|
|
}
|
|
}
|
|
|
|
// Validate Day and Month strings
|
|
dwRetval = ValidateDayAndMonth( tcresubops.szDays, tcresubops.szMonths,
|
|
dwScheduleType,
|
|
cmdOptions[OI_CREATE_DAY].dwActuals,
|
|
cmdOptions[OI_CREATE_MONTHS].dwActuals,
|
|
cmdOptions[OI_CREATE_MODIFIER].dwActuals,
|
|
tcresubops.szModifier);
|
|
if(RETVAL_FAIL == dwRetval )
|
|
{
|
|
return dwRetval; // Error found in Day/Month string.
|
|
}
|
|
|
|
// Validate Start Date value.
|
|
dwRetval = ValidateStartDate( tcresubops.szStartDate, dwScheduleType,
|
|
cmdOptions[OI_CREATE_STARTDATE].dwActuals,
|
|
bIsStDtCurDt);
|
|
if(RETVAL_FAIL == dwRetval )
|
|
{
|
|
return dwRetval; // Error in Day/Month string.
|
|
}
|
|
else
|
|
{
|
|
if(bIsStDtCurDt) // Set start date to current date.
|
|
{
|
|
tcreoptvals.bSetStartDateToCurDate = TRUE;
|
|
}
|
|
}
|
|
|
|
// Validate End Date value.
|
|
dwRetval = ValidateEndDate( tcresubops.szEndDate, dwScheduleType,
|
|
cmdOptions[OI_CREATE_ENDDATE].dwActuals);
|
|
if(RETVAL_FAIL == dwRetval )
|
|
{
|
|
return dwRetval; // Error in Day/Month string.
|
|
}
|
|
|
|
//Check Whether end date should be greater than startdate
|
|
|
|
WORD wEndDay = 0;
|
|
WORD wEndMonth = 0;
|
|
WORD wEndYear = 0;
|
|
WORD wStartDay = 0;
|
|
WORD wStartMonth = 0;
|
|
WORD wStartYear = 0;
|
|
|
|
if( cmdOptions[OI_CREATE_ENDDATE].dwActuals != 0 )
|
|
{
|
|
if( RETVAL_FAIL == GetDateFieldEntities( tcresubops.szEndDate,&wEndDay,
|
|
&wEndMonth,&wEndYear))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
|
|
SYSTEMTIME systime = {0,0,0,0,0,0,0,0};
|
|
|
|
if(bIsStDtCurDt)
|
|
{
|
|
GetLocalTime(&systime);
|
|
wStartDay = systime.wDay;
|
|
wStartMonth = systime.wMonth;
|
|
wStartYear = systime.wYear;
|
|
}
|
|
else if( ( cmdOptions[OI_CREATE_STARTDATE].dwActuals != 0 ) &&
|
|
(RETVAL_FAIL == GetDateFieldEntities(tcresubops.szStartDate,
|
|
&wStartDay,&wStartMonth,
|
|
&wStartYear)))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if( (cmdOptions[OI_CREATE_ENDDATE].dwActuals != 0) )
|
|
{
|
|
if( ( wEndYear == wStartYear ) )
|
|
{
|
|
// For same years if the end month is less than start month or for same years and same months
|
|
// if the endday is less than the startday.
|
|
if ( ( wEndMonth < wStartMonth ) || ( ( wEndMonth == wStartMonth ) && ( wEndDay < wStartDay ) ) )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_ENDATE_INVALID));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
|
|
}
|
|
else if ( wEndYear < wStartYear )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_ENDATE_INVALID));
|
|
return RETVAL_FAIL;
|
|
|
|
}
|
|
}
|
|
|
|
// Validate Start Time value.
|
|
dwRetval = ValidateStartTime( tcresubops.szStartTime, dwScheduleType,
|
|
cmdOptions[OI_CREATE_STARTTIME].dwActuals,
|
|
bIsStTimeCurTime);
|
|
if ( RETVAL_FAIL == dwRetval )
|
|
{
|
|
return dwRetval; // Error found in starttime.
|
|
}
|
|
else
|
|
{
|
|
if(bIsStTimeCurTime)
|
|
{
|
|
tcreoptvals.bSetStartTimeToCurTime = TRUE;
|
|
}
|
|
}
|
|
|
|
// Validate End Time value.
|
|
dwRetval = ValidateEndTime( tcresubops.szEndTime, dwScheduleType,
|
|
cmdOptions[OI_CREATE_ENDTIME].dwActuals);
|
|
if ( RETVAL_FAIL == dwRetval )
|
|
{
|
|
return dwRetval; // Error found in endtime.
|
|
}
|
|
|
|
// Validate Idle Time value.
|
|
dwRetval = ValidateIdleTimeVal( tcresubops.szIdleTime, dwScheduleType,
|
|
cmdOptions[OI_CREATE_IDLETIME].dwActuals);
|
|
if ( RETVAL_FAIL == dwRetval )
|
|
{
|
|
|
|
return dwRetval;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
Checks whether password to be prompted for remote system or not.
|
|
|
|
Arguments:
|
|
|
|
[ in ] szServer : Server name
|
|
[ in ] szUser : User name
|
|
[ in ] szPassword : Password
|
|
[ in ] cmdOptions : TCMDPARSER Array containg the options given by the user
|
|
[ in ] tcreoptvals: Structure containing optional values to set
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL
|
|
on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateRemoteSysInfo(
|
|
IN TCMDPARSER2 cmdOptions[],
|
|
IN TCREATESUBOPTS& tcresubops,
|
|
IN TCREATEOPVALS& tcreoptvals
|
|
)
|
|
{
|
|
|
|
BOOL bIsLocalSystem = FALSE;
|
|
|
|
// "-rp" should not be specified without "-ru"
|
|
if ( ( ( cmdOptions[ OI_CREATE_RUNASUSERNAME ].dwActuals == 0 ) && ( cmdOptions[ OI_CREATE_RUNASPASSWORD ].dwActuals == 1 ) ) ||
|
|
( ( cmdOptions[ OI_CREATE_USERNAME ].dwActuals == 0 ) && ( cmdOptions[ OI_CREATE_PASSWORD ].dwActuals == 1 ) ) ||
|
|
( ( cmdOptions[ OI_CREATE_USERNAME ].dwActuals == 0 ) && ( cmdOptions[ OI_CREATE_RUNASPASSWORD ].dwActuals == 1 ) && ( cmdOptions[ OI_CREATE_PASSWORD ].dwActuals == 1 ) ) ||
|
|
( ( cmdOptions[ OI_CREATE_RUNASUSERNAME ].dwActuals == 0 ) && ( cmdOptions[ OI_CREATE_RUNASPASSWORD ].dwActuals == 1 ) && ( cmdOptions[ OI_CREATE_PASSWORD ].dwActuals == 1 ) ) ||
|
|
( ( cmdOptions[ OI_CREATE_USERNAME ].dwActuals == 0 ) && ( cmdOptions[ OI_CREATE_RUNASUSERNAME ].dwActuals == 0 ) &&
|
|
( cmdOptions[ OI_CREATE_RUNASPASSWORD ].dwActuals == 1 ) && ( cmdOptions[ OI_CREATE_PASSWORD ].dwActuals == 1 ) ) )
|
|
{
|
|
// invalid syntax
|
|
ShowMessage(stderr, GetResString(IDS_CPASSWORD_BUT_NOUSERNAME));
|
|
return RETVAL_FAIL; // indicate failure
|
|
}
|
|
|
|
tcreoptvals.bPassword = FALSE;
|
|
|
|
bIsLocalSystem = IsLocalSystem( tcresubops.szServer );
|
|
if ( TRUE == bIsLocalSystem )
|
|
{
|
|
tcreoptvals.bPassword = FALSE;
|
|
}
|
|
|
|
// check whether the password (-p) specified in the command line or not
|
|
// and also check whether '*' or empty is given for -p or not
|
|
// check whether the password (-p) specified in the command line or not
|
|
// and also check whether '*' or empty is given for -p or not
|
|
// check whether the password (-p) specified in the command line or not
|
|
// and also check whether '*' or empty is given for -p or not
|
|
// check the remote connectivity information
|
|
if ( tcresubops.szServer != NULL )
|
|
{
|
|
//
|
|
// if -u is not specified, we need to allocate memory
|
|
// in order to be able to retrive the current user name
|
|
//
|
|
// case 1: -p is not at all specified
|
|
// as the value for this switch is optional, we have to rely
|
|
// on the dwActuals to determine whether the switch is specified or not
|
|
// in this case utility needs to try to connect first and if it fails
|
|
// then prompt for the password -- in fact, we need not check for this
|
|
// condition explicitly except for noting that we need to prompt for the
|
|
// password
|
|
//
|
|
// case 2: -p is specified
|
|
// but we need to check whether the value is specified or not
|
|
// in this case user wants the utility to prompt for the password
|
|
// before trying to connect
|
|
//
|
|
// case 3: -p * is specified
|
|
|
|
// user name
|
|
if ( tcresubops.szUser == NULL )
|
|
{
|
|
tcresubops.szUser = (LPWSTR) AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) );
|
|
if ( tcresubops.szUser == NULL )
|
|
{
|
|
SaveLastError();
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
|
|
// password
|
|
if ( tcresubops.szPassword == NULL )
|
|
{
|
|
tcreoptvals.bPassword = TRUE;
|
|
tcresubops.szPassword = (LPWSTR)AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) );
|
|
if ( tcresubops.szPassword == NULL )
|
|
{
|
|
SaveLastError();
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
|
|
// case 1
|
|
if ( cmdOptions[ OI_CREATE_PASSWORD ].dwActuals == 0 )
|
|
{
|
|
// we need not do anything special here
|
|
}
|
|
|
|
// case 2
|
|
else if ( cmdOptions[ OI_CREATE_PASSWORD ].pValue == NULL )
|
|
{
|
|
StringCopy( tcresubops.szPassword, L"*", GetBufferSize(tcresubops.szPassword)/sizeof(WCHAR));
|
|
}
|
|
|
|
// case 3
|
|
else if ( StringCompareEx( tcresubops.szPassword, L"*", TRUE, 0 ) == 0 )
|
|
{
|
|
if ( ReallocateMemory( (LPVOID*)&tcresubops.szPassword,
|
|
MAX_STRING_LENGTH * sizeof( WCHAR ) ) == FALSE )
|
|
{
|
|
SaveLastError();
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
// ...
|
|
tcreoptvals.bPassword = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
if( ( cmdOptions[ OI_CREATE_RUNASPASSWORD ].dwActuals == 1 ) )
|
|
{
|
|
tcreoptvals.bRunAsPassword = TRUE;
|
|
|
|
|
|
if ( cmdOptions[ OI_CREATE_RUNASPASSWORD ].pValue == NULL )
|
|
{
|
|
|
|
tcresubops.szRunAsPassword = (LPWSTR)AllocateMemory( MAX_STRING_LENGTH * sizeof( WCHAR ) );
|
|
if ( NULL == tcresubops.szRunAsPassword)
|
|
{
|
|
SaveLastError();
|
|
return RETVAL_FAIL;
|
|
}
|
|
StringCopy( tcresubops.szRunAsPassword, L"*", GetBufferSize(tcresubops.szRunAsPassword)/sizeof(WCHAR));
|
|
}
|
|
}
|
|
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates & determines the modifier value .
|
|
|
|
Arguments:
|
|
|
|
[ in ] szModifier : Modifer value
|
|
[ in ] dwScheduleType : Type of schedule[Daily,once,weekly etc]
|
|
[ in ] dwModOptActCnt : Modifier optional value
|
|
[ in ] dwDayOptCnt : Days value
|
|
[ in ] dwMonOptCnt : Months value
|
|
[ out ] bIsDefltValMod : Whether default value should be given for modifier
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL
|
|
on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateModifierVal(
|
|
IN LPCTSTR szModifier,
|
|
IN DWORD dwScheduleType,
|
|
IN DWORD dwModOptActCnt,
|
|
IN DWORD dwDayOptCnt,
|
|
IN DWORD dwMonOptCnt,
|
|
OUT BOOL& bIsDefltValMod
|
|
)
|
|
{
|
|
|
|
WCHAR szDayType[MAX_RES_STRING] = L"\0";
|
|
ULONG dwModifier = 0;
|
|
|
|
StringCopy(szDayType,GetResString(IDS_TASK_FIRSTWEEK), SIZE_OF_ARRAY(szDayType));
|
|
StringConcat(szDayType,_T("|"), SIZE_OF_ARRAY(szDayType));
|
|
StringConcat(szDayType,GetResString(IDS_TASK_SECONDWEEK), SIZE_OF_ARRAY(szDayType));
|
|
StringConcat(szDayType,_T("|"), SIZE_OF_ARRAY(szDayType));
|
|
StringConcat(szDayType,GetResString(IDS_TASK_THIRDWEEK), SIZE_OF_ARRAY(szDayType));
|
|
StringConcat(szDayType,_T("|"), SIZE_OF_ARRAY(szDayType));
|
|
StringConcat(szDayType,GetResString(IDS_TASK_FOURTHWEEK), SIZE_OF_ARRAY(szDayType));
|
|
StringConcat(szDayType,_T("|"), SIZE_OF_ARRAY(szDayType));
|
|
StringConcat(szDayType,GetResString(IDS_TASK_LASTWEEK), SIZE_OF_ARRAY(szDayType));
|
|
|
|
|
|
bIsDefltValMod = FALSE; // If TRUE : Set modifier to default value, 1.
|
|
LPWSTR pszStopString = NULL;
|
|
|
|
|
|
switch( dwScheduleType )
|
|
{
|
|
|
|
case SCHED_TYPE_MINUTE: // Schedule type is Minute
|
|
|
|
if( (dwModOptActCnt <= 0) || (StringLength(szModifier, 0) <= 0) )
|
|
{
|
|
|
|
bIsDefltValMod = TRUE;
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
dwModifier = wcstoul(szModifier,&pszStopString,BASE_TEN);
|
|
|
|
// check whether alpha-numneric value specified or not..
|
|
// Also, check for underflow/overflow.
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
break;
|
|
}
|
|
|
|
|
|
if( dwModifier > 0 && dwModifier < 1440 ) // Valid Range 1 - 1439
|
|
return RETVAL_SUCCESS;
|
|
|
|
break;
|
|
|
|
// Schedule type is Hourly
|
|
case SCHED_TYPE_HOURLY:
|
|
|
|
if( (dwModOptActCnt <= 0) || (StringLength(szModifier, 0) <= 0) )
|
|
{
|
|
|
|
bIsDefltValMod = TRUE;
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
|
|
dwModifier = wcstoul(szModifier,&pszStopString,BASE_TEN);
|
|
|
|
// check whether alpha-numneric value specified or not..
|
|
// Also, check for underflow/overflow.
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( dwModifier > 0 && dwModifier < 24 ) // Valid Range 1 - 23
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
break;
|
|
|
|
// Schedule type is Daily
|
|
case SCHED_TYPE_DAILY:
|
|
// -days option is NOT APPLICABLE for DAILY type item.
|
|
|
|
if( (dwDayOptCnt > 0) )
|
|
{// Invalid sysntax. Return error
|
|
// Modifier option and days options both should not specified same time.
|
|
bIsDefltValMod = FALSE;
|
|
ShowMessage(stderr, GetResString(IDS_DAYS_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
// -months option is NOT APPLICABLE for DAILY type item.
|
|
if( dwMonOptCnt > 0 )
|
|
{// Invalid sysntax. Return error
|
|
// Modifier option and days options both should not specified same time.
|
|
bIsDefltValMod = FALSE;
|
|
ShowMessage(stderr , GetResString(IDS_MON_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
// Check whether the -modifier switch is psecified. If not, then take default value.
|
|
if( (dwModOptActCnt <= 0) || (StringLength(szModifier, 0) <= 0) )
|
|
{
|
|
// Modifier options is not specified. So, set it to default value. (i.e, 1 )
|
|
bIsDefltValMod = TRUE;
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
dwModifier = wcstoul(szModifier,&pszStopString,BASE_TEN);
|
|
|
|
// check whether alpha-numneric value specified or not..
|
|
// Also, check for underflow/overflow.
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
break;
|
|
}
|
|
|
|
// If the -modifier option is specified, then validate the value.
|
|
if( dwModifier > 0 && dwModifier < 366 ) // Valid Range 1 - 365
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_MODIFIER));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
break;
|
|
|
|
// Schedule type is Weekly
|
|
case SCHED_TYPE_WEEKLY:
|
|
|
|
// If -modifier option is not specified, then set it to default value.
|
|
if( (dwModOptActCnt <= 0) || (StringLength(szModifier, 0) <= 0) )
|
|
{
|
|
// Modifier options is not specified. So, set it to default value. (i.e, 1 )
|
|
bIsDefltValMod = TRUE;
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
|
|
if( dwModOptActCnt > 0)
|
|
{
|
|
dwModifier = wcstoul(szModifier,&pszStopString,BASE_TEN);
|
|
// check whether alpha-numneric value specified or not..
|
|
// Also, check for underflow/overflow.
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( dwModifier > 0 && dwModifier < 53 ) // Valid Range 1 - 52
|
|
return RETVAL_SUCCESS;
|
|
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
// Schedule type is Monthly
|
|
case SCHED_TYPE_MONTHLY:
|
|
|
|
// If -modifier option is not specified, then set it to default value.
|
|
if( ( dwModOptActCnt > 0) && (StringLength(szModifier, 0) == 0) )
|
|
{
|
|
// Modifier option is not proper. So display error and return false.
|
|
bIsDefltValMod = FALSE;
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_MODIFIER));
|
|
return RETVAL_FAIL;
|
|
}
|
|
//check if the modifier is LASTDAY[not case sensitive]
|
|
if( StringCompare( szModifier , GetResString( IDS_DAY_MODIFIER_LASTDAY ), TRUE, 0 ) == 0)
|
|
return RETVAL_SUCCESS;
|
|
|
|
//Check if -mo is in between FIRST,SECOND ,THIRD, LAST
|
|
//then -days[ MON to SUN ] is applicable , -months is also applicable
|
|
|
|
if( InString ( szModifier , szDayType , TRUE ) )
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
dwModifier = wcstoul(szModifier,&pszStopString,BASE_TEN);
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( ( dwModOptActCnt == 1 ) && ( dwModifier < 1 || dwModifier > 12 ) ) //check whether -mo value is in between 1 - 12
|
|
{
|
|
//invalid -mo value
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_MODIFIER));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
break;
|
|
|
|
case SCHED_TYPE_ONETIME:
|
|
case SCHED_TYPE_ONSTART:
|
|
case SCHED_TYPE_ONLOGON:
|
|
case SCHED_TYPE_ONIDLE:
|
|
|
|
if( dwModOptActCnt <= 0 )
|
|
{
|
|
// Modifier option is not applicable. So, return success.
|
|
bIsDefltValMod = FALSE;
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
// Modifier option is not applicable. But specified. So, return error.
|
|
bIsDefltValMod = FALSE;
|
|
ShowMessage(stderr, GetResString(IDS_MODIFIER_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return RETVAL_FAIL;
|
|
|
|
}
|
|
|
|
// Modifier option is not proper. So display error and return false.
|
|
bIsDefltValMod = FALSE;
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_MODIFIER));
|
|
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates & determines the day,month value .
|
|
|
|
Arguments:
|
|
|
|
[ in ] szDay : Day value
|
|
[ in ] szMonths : Months[Daily,once,weekly etc]
|
|
[ in ] dwSchedType : Modifier optional value
|
|
[ in ] dwDayOptCnt : Days option value
|
|
[ in ] dwMonOptCnt : Months option value
|
|
[ in ] dwOptModifier : Modifier option value
|
|
[ in ] szModifier : Whether default value for modifier
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL
|
|
on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateDayAndMonth(
|
|
IN LPWSTR szDay,
|
|
IN LPWSTR szMonths,
|
|
IN DWORD dwSchedType,
|
|
IN DWORD dwDayOptCnt,
|
|
IN DWORD dwMonOptCnt,
|
|
IN DWORD dwOptModifier,
|
|
IN LPWSTR szModifier
|
|
)
|
|
{
|
|
|
|
DWORD dwRetval = 0;
|
|
DWORD dwModifier = 0;
|
|
DWORD dwDays = 0;
|
|
WCHAR szDayModifier[MAX_RES_STRING] = L"\0";
|
|
|
|
//get the valid week day modifiers from the rc file
|
|
StringCopy(szDayModifier,GetResString(IDS_TASK_FIRSTWEEK), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_TASK_SECONDWEEK), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_TASK_THIRDWEEK), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_TASK_FOURTHWEEK), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_TASK_LASTWEEK), SIZE_OF_ARRAY(szDayModifier));
|
|
|
|
switch (dwSchedType)
|
|
{
|
|
case SCHED_TYPE_DAILY:
|
|
// -days and -months optons is not applicable. SO, check for it.
|
|
if( dwDayOptCnt > 0 || dwMonOptCnt > 0)
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
|
|
case SCHED_TYPE_MONTHLY:
|
|
|
|
if( dwMonOptCnt > 0 && StringLength(szMonths, 0) == 0)
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_MONTH_MODFIER));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
//if the modifier is LASTDAY
|
|
if( StringCompare( szModifier , GetResString( IDS_DAY_MODIFIER_LASTDAY ), TRUE, 0 ) == 0)
|
|
{
|
|
//-day is not applicable for this case only -months is applicable
|
|
if( dwDayOptCnt > 0 )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_DAYS_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if(StringLength(szMonths, 0))
|
|
{
|
|
|
|
if( ( ValidateMonth( szMonths ) == RETVAL_SUCCESS ) ||
|
|
InString( szMonths, ASTERIX, TRUE ) )
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
ShowMessage(stderr , GetResString(IDS_INVALID_VALUE_FOR_MON));
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_NO_MONTH_VALUE));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
}
|
|
|
|
// If -day is specified then check whether the day value is valid or not.
|
|
if( InString( szDay, ASTERIX, TRUE) )
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_INVALID_VALUE_FOR_DAY));
|
|
return RETVAL_FAIL;
|
|
}
|
|
if(( StringLength (szDay, 0 ) == 0 ) && InString(szModifier, szDayModifier, TRUE))
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_NO_DAY_VALUE));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if( dwDayOptCnt )
|
|
{
|
|
dwModifier = (DWORD) AsLong(szModifier, BASE_TEN);
|
|
|
|
//check for multiples days,if then return error
|
|
|
|
if ( wcspbrk ( szDay , COMMA_STRING ) )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_VALUE_FOR_DAY));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
|
|
if( ValidateDay( szDay ) == RETVAL_SUCCESS )
|
|
{
|
|
//Check the modifier value should be in FIRST, SECOND, THIRD, FOURTH, LAST OR LASTDAY etc..
|
|
if(!( InString(szModifier, szDayModifier, TRUE) ) )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_VALUE_FOR_DAY));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
dwDays = (DWORD) AsLong(szDay, BASE_TEN);
|
|
|
|
if( ( dwDays < 1 ) || ( dwDays > 31 ) )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_VALUE_FOR_DAY));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if( ( dwOptModifier == 1 ) && ( ( dwModifier < 1 ) || ( dwModifier > 12 ) ) )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_MODIFIER));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if( InString(szModifier, szDayModifier, TRUE) )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_VALUE_FOR_DAY));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if(dwMonOptCnt && StringLength(szModifier, 0))
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_INVALID_MONTH_MODFIER));
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
|
|
} //end of dwDayOptCnt
|
|
|
|
if(StringLength(szMonths, 0))
|
|
{
|
|
|
|
if( StringLength(szModifier, 0) )
|
|
{
|
|
dwModifier = (DWORD) AsLong(szModifier, BASE_TEN);
|
|
|
|
if(dwModifier >= 1 && dwModifier <= 12)
|
|
{
|
|
ShowMessage( stderr ,GetResString(IDS_MON_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
|
|
if( ( ValidateMonth( szMonths ) == RETVAL_SUCCESS ) ||
|
|
InString( szMonths, ASTERIX, TRUE ) )
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_INVALID_VALUE_FOR_MON));
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
|
|
|
|
// assgin default values for month,day
|
|
return RETVAL_SUCCESS;
|
|
|
|
case SCHED_TYPE_HOURLY:
|
|
case SCHED_TYPE_ONETIME:
|
|
case SCHED_TYPE_ONSTART:
|
|
case SCHED_TYPE_ONLOGON:
|
|
case SCHED_TYPE_ONIDLE:
|
|
case SCHED_TYPE_MINUTE:
|
|
|
|
// -months switch is NOT APPLICABLE.
|
|
if( dwMonOptCnt > 0 )
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_MON_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
// -days switch is NOT APPLICABLE.
|
|
if( dwDayOptCnt > 0 )
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_DAYS_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
break;
|
|
|
|
case SCHED_TYPE_WEEKLY:
|
|
|
|
// -months field is NOT APPLICABLE for WEEKLY item.
|
|
if( dwMonOptCnt > 0 )
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_MON_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
|
|
if(dwDayOptCnt > 0)
|
|
{
|
|
dwRetval = ValidateDay(szDay);
|
|
if( RETVAL_FAIL == dwRetval )
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_INVALID_VALUE_FOR_DAY));
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
|
|
|
|
return RETVAL_SUCCESS;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the months values specified by the user
|
|
|
|
Arguments:
|
|
|
|
[ in ] szMonths : Months options given by user
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL
|
|
on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateMonth(
|
|
IN LPWSTR szMonths
|
|
)
|
|
{
|
|
WCHAR* pMonthstoken = NULL; // For getting months.
|
|
WCHAR seps[] = _T(", \n");
|
|
WCHAR szMonthsList[MAX_STRING_LENGTH] = L"\0";
|
|
WCHAR szTmpMonths[MAX_STRING_LENGTH] = L"\0";
|
|
WCHAR szPrevTokens[MAX_TOKENS_LENGTH] = L"\0";
|
|
LPCTSTR lpsz = NULL;
|
|
|
|
// If the szMonths string is empty or NULL return error.
|
|
if( szMonths == NULL )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
else
|
|
{
|
|
lpsz = szMonths;
|
|
}
|
|
|
|
//check for any illegal input like only ,DEC,[comma at the end of month name or before]
|
|
if(*lpsz == _T(','))
|
|
return RETVAL_FAIL;
|
|
|
|
lpsz = _wcsdec(lpsz, lpsz + StringLength(lpsz, 0) );
|
|
|
|
if( lpsz != NULL )
|
|
{
|
|
if( *lpsz == _T(','))
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
//get the valid month modifiers from the rc file
|
|
StringCopy(szMonthsList,GetResString(IDS_MONTH_MODIFIER_JAN), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_FEB), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_MAR), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_APR), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_MAY), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_JUN), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_JUL), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_AUG), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_SEP), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_OCT), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_NOV), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,_T("|"), SIZE_OF_ARRAY(szMonthsList));
|
|
StringConcat(szMonthsList,GetResString(IDS_MONTH_MODIFIER_DEC), SIZE_OF_ARRAY(szMonthsList));
|
|
|
|
if( InString( szMonths , szMonthsList , TRUE ) &&
|
|
InString( szMonths , ASTERIX , TRUE ) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if( InString( szMonths , ASTERIX , TRUE ) )
|
|
return RETVAL_SUCCESS;
|
|
|
|
//Check for multiple commas[,] after months like FEB,,,MAR errors
|
|
lpsz = szMonths;
|
|
while ( StringLength ( lpsz, 0 ) )
|
|
{
|
|
if(*lpsz == _T(','))
|
|
{
|
|
lpsz = _wcsinc(lpsz);
|
|
while ( ( lpsz != NULL ) && ( _istspace(*lpsz) ) )
|
|
lpsz = _wcsinc(lpsz);
|
|
|
|
if( lpsz != NULL )
|
|
{
|
|
if(*lpsz == _T(','))
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
}
|
|
else
|
|
lpsz = _wcsinc(lpsz);
|
|
}
|
|
|
|
StringCopy(szTmpMonths, szMonths, SIZE_OF_ARRAY(szTmpMonths));
|
|
|
|
WCHAR* pPrevtoken = NULL;
|
|
pMonthstoken = wcstok( szTmpMonths, seps );
|
|
|
|
if( !(InString(pMonthstoken, szMonthsList, TRUE)) )
|
|
return RETVAL_FAIL;
|
|
|
|
if( pMonthstoken )
|
|
StringCopy ( szPrevTokens, pMonthstoken, SIZE_OF_ARRAY(szPrevTokens));
|
|
|
|
while( pMonthstoken != NULL )
|
|
{
|
|
//check if month names are replicated like MAR,MAR from user input
|
|
pPrevtoken = pMonthstoken;
|
|
pMonthstoken = wcstok( NULL, seps );
|
|
|
|
if ( pMonthstoken == NULL)
|
|
return RETVAL_SUCCESS;
|
|
|
|
if( !(InString(pMonthstoken, szMonthsList, TRUE)) )
|
|
return RETVAL_FAIL;
|
|
|
|
if( InString(pMonthstoken,szPrevTokens, TRUE) )
|
|
return RETVAL_FAIL;
|
|
|
|
StringConcat( szPrevTokens, _T("|"), SIZE_OF_ARRAY(szPrevTokens));
|
|
StringConcat( szPrevTokens, pMonthstoken, SIZE_OF_ARRAY(szPrevTokens));
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the days values specified by the user
|
|
|
|
Arguments:
|
|
|
|
[ in ] szDays : Days options given by user
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL
|
|
on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateDay(
|
|
IN LPWSTR szDays
|
|
)
|
|
{
|
|
WCHAR* pDaystoken = NULL;
|
|
WCHAR seps[] = _T(", \n");
|
|
WCHAR szDayModifier[MAX_STRING_LENGTH ] = L"\0";
|
|
WCHAR szTmpDays[MAX_STRING_LENGTH] = L"\0";
|
|
|
|
//get the valid day modifiers from the rc file
|
|
StringCopy(szDayModifier,GetResString(IDS_DAY_MODIFIER_SUN), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_DAY_MODIFIER_MON), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_DAY_MODIFIER_TUE), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_DAY_MODIFIER_WED), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_DAY_MODIFIER_THU), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_DAY_MODIFIER_FRI), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,_T("|"), SIZE_OF_ARRAY(szDayModifier));
|
|
StringConcat(szDayModifier,GetResString(IDS_DAY_MODIFIER_SAT), SIZE_OF_ARRAY(szDayModifier));
|
|
|
|
//check for any illegal input like MON, or ,MON [comma at the end of day name or before]
|
|
LPCTSTR lpsz = NULL;
|
|
if( szDays != NULL)
|
|
lpsz = szDays;
|
|
else
|
|
return RETVAL_FAIL;
|
|
|
|
if(*lpsz == _T(','))
|
|
return RETVAL_FAIL;
|
|
|
|
lpsz = _wcsdec(lpsz, lpsz + StringLength(lpsz, 0) );
|
|
if( lpsz != NULL )
|
|
{
|
|
if( *lpsz == _T(',') )
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if ( ( lpsz != NULL ) && ( _istspace(*lpsz) ))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if( (InString( szDays , szDayModifier , TRUE )) || (InString( szDays , ASTERIX , TRUE )))
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
//Check for multiple commas[,] after days like SUN,,,TUE errors
|
|
lpsz = szDays;
|
|
while ( StringLength ( lpsz, 0 ) )
|
|
{
|
|
if(*lpsz == _T(','))
|
|
{
|
|
lpsz = _wcsinc(lpsz);
|
|
while ( ( lpsz != NULL ) && ( _istspace(*lpsz) ))
|
|
lpsz = _wcsinc(lpsz);
|
|
|
|
if( lpsz != NULL )
|
|
{
|
|
if(*lpsz == _T(','))
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
lpsz = _wcsinc(lpsz);
|
|
}
|
|
}
|
|
|
|
if(szDays != NULL)
|
|
{
|
|
StringCopy(szTmpDays, szDays, SIZE_OF_ARRAY(szTmpDays));
|
|
}
|
|
|
|
// If the szDays string is empty or NULL return error.
|
|
if( (StringLength(szTmpDays, 0) <= 0) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
//WCHAR* pPrevtoken = NULL;
|
|
WCHAR szPrevtokens[MAX_TOKENS_LENGTH] = L"\0";
|
|
|
|
// Establish string and get the first token:
|
|
pDaystoken = wcstok( szTmpDays, seps );
|
|
|
|
if( pDaystoken )
|
|
{
|
|
StringCopy( szPrevtokens , pDaystoken, SIZE_OF_ARRAY(szPrevtokens) );
|
|
}
|
|
|
|
while( pDaystoken != NULL )
|
|
{
|
|
//check if day names are replicated like SUN,MON,SUN from user input
|
|
|
|
if( !(InString(pDaystoken,szDayModifier,TRUE)) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
pDaystoken = wcstok( NULL, seps );
|
|
if( pDaystoken )
|
|
{
|
|
if( (InString(pDaystoken,szPrevtokens,TRUE)) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
StringConcat( szPrevtokens , _T("|"), SIZE_OF_ARRAY(szPrevtokens) );
|
|
StringConcat( szPrevtokens , pDaystoken , SIZE_OF_ARRAY(szPrevtokens));
|
|
}
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the start date specified by the user
|
|
|
|
Arguments:
|
|
|
|
[ in ] szStartDate : Start date specified by user
|
|
[ in ] dwSchedType : Schedule type
|
|
[ in ] dwStDtOptCnt : whether start date specified by the user
|
|
[ out ] bIsCurrentDate : If start date not specified then startdate = current date
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL
|
|
on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateStartDate(
|
|
IN LPWSTR szStartDate,
|
|
IN DWORD dwSchedType,
|
|
IN DWORD dwStDtOptCnt,
|
|
OUT BOOL &bIsCurrentDate
|
|
)
|
|
{
|
|
|
|
DWORD dwRetval = RETVAL_SUCCESS;
|
|
bIsCurrentDate = FALSE; // If TRUE : Startdate should be set to Current Date.
|
|
|
|
WCHAR szFormat[MAX_DATE_STR_LEN] = L"\0";
|
|
|
|
if ( RETVAL_FAIL == GetDateFormatString( szFormat) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
switch (dwSchedType)
|
|
{
|
|
case SCHED_TYPE_MINUTE:
|
|
case SCHED_TYPE_HOURLY:
|
|
case SCHED_TYPE_DAILY:
|
|
case SCHED_TYPE_WEEKLY:
|
|
case SCHED_TYPE_MONTHLY:
|
|
case SCHED_TYPE_ONIDLE:
|
|
case SCHED_TYPE_ONSTART:
|
|
case SCHED_TYPE_ONLOGON:
|
|
|
|
if( (dwStDtOptCnt <= 0))
|
|
{
|
|
bIsCurrentDate = TRUE;
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
// validate the date string
|
|
dwRetval = ValidateDateString(szStartDate, TRUE );
|
|
if(RETVAL_FAIL == dwRetval)
|
|
{
|
|
return dwRetval;
|
|
}
|
|
return RETVAL_SUCCESS;
|
|
|
|
case SCHED_TYPE_ONETIME:
|
|
|
|
if( (dwStDtOptCnt <= 0))
|
|
{
|
|
bIsCurrentDate = TRUE;
|
|
return RETVAL_SUCCESS;
|
|
|
|
}
|
|
|
|
dwRetval = ValidateDateString(szStartDate, TRUE );
|
|
if(RETVAL_FAIL == dwRetval)
|
|
{
|
|
return dwRetval;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
|
|
default:
|
|
|
|
// validate the date string
|
|
dwRetval = ValidateDateString(szStartDate, TRUE );
|
|
if(RETVAL_FAIL == dwRetval)
|
|
{
|
|
return dwRetval;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
|
|
}
|
|
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the end date specified by the user
|
|
|
|
Arguments:
|
|
|
|
[ in ] szEndDate : End date specified by user
|
|
[ in ] dwSchedType : Schedule type
|
|
[ in ] dwEndDtOptCnt : whether end date specified by the user
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else RETVAL_FAIL
|
|
on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateEndDate(
|
|
IN LPWSTR szEndDate,
|
|
IN DWORD dwSchedType,
|
|
IN DWORD dwEndDtOptCnt
|
|
)
|
|
{
|
|
|
|
DWORD dwRetval = RETVAL_SUCCESS; // return value
|
|
WCHAR szFormat[MAX_DATE_STR_LEN] = L"\0";
|
|
|
|
if ( RETVAL_FAIL == GetDateFormatString( szFormat) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
switch (dwSchedType)
|
|
{
|
|
case SCHED_TYPE_MINUTE:
|
|
case SCHED_TYPE_HOURLY:
|
|
case SCHED_TYPE_DAILY:
|
|
case SCHED_TYPE_WEEKLY:
|
|
case SCHED_TYPE_MONTHLY:
|
|
|
|
|
|
if( (dwEndDtOptCnt <= 0))
|
|
{
|
|
// No default value & Value is not mandatory.. so return success.
|
|
szEndDate = L"\0"; // Set to empty string.
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
// validate end date string
|
|
dwRetval = ValidateDateString(szEndDate, FALSE );
|
|
if( RETVAL_FAIL == dwRetval )
|
|
{
|
|
return dwRetval;
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case SCHED_TYPE_ONSTART:
|
|
case SCHED_TYPE_ONLOGON:
|
|
case SCHED_TYPE_ONIDLE:
|
|
case SCHED_TYPE_ONETIME:
|
|
|
|
if( dwEndDtOptCnt > 0 )
|
|
{
|
|
// Error. End date is not applicable here, but option specified.
|
|
ShowMessage(stderr,GetResString(IDS_ENDDATE_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
// validate end date string
|
|
dwRetval = ValidateDateString(szEndDate, FALSE );
|
|
if( RETVAL_FAIL == dwRetval )
|
|
{
|
|
return dwRetval;
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the start time specified by the user
|
|
|
|
Arguments:
|
|
|
|
[ in ] szStartTime : End date specified by user
|
|
[ in ] dwSchedType : Schedule type
|
|
[ in ] dwStTimeOptCnt : whether end date specified by the user
|
|
[ out ] bIsCurrentTime : Determine if start time is present else assign
|
|
to current time
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
DWORD
|
|
ValidateStartTime(
|
|
IN LPWSTR szStartTime,
|
|
IN DWORD dwSchedType,
|
|
IN DWORD dwStTimeOptCnt,
|
|
OUT BOOL &bIsCurrentTime
|
|
)
|
|
{
|
|
|
|
DWORD dwRetval = RETVAL_SUCCESS; // return value
|
|
bIsCurrentTime = FALSE; // If TRUE : Startdate should be set to Current Date.
|
|
|
|
switch (dwSchedType)
|
|
{
|
|
case SCHED_TYPE_MINUTE:
|
|
case SCHED_TYPE_HOURLY:
|
|
case SCHED_TYPE_DAILY:
|
|
case SCHED_TYPE_WEEKLY:
|
|
case SCHED_TYPE_MONTHLY:
|
|
|
|
if( (dwStTimeOptCnt <= 0))
|
|
{
|
|
bIsCurrentTime = TRUE;
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
dwRetval = ValidateTimeString(szStartTime);
|
|
|
|
if(RETVAL_FAIL == dwRetval)
|
|
{
|
|
// Error. Invalid date string.
|
|
ShowMessage(stderr,GetResString(IDS_INVALIDFORMAT_STARTTIME));
|
|
return dwRetval;
|
|
}
|
|
return RETVAL_SUCCESS;
|
|
|
|
case SCHED_TYPE_ONETIME:
|
|
|
|
dwRetval = ValidateTimeString(szStartTime);
|
|
|
|
if( (dwStTimeOptCnt <= 0))
|
|
{
|
|
// Error. Start Time is not specified.
|
|
ShowMessage(stderr,GetResString(IDS_NO_STARTTIME));
|
|
return RETVAL_FAIL;
|
|
}
|
|
else if(RETVAL_FAIL == dwRetval)
|
|
{
|
|
// Error. Invalid date string.
|
|
ShowMessage(stderr,GetResString(IDS_INVALIDFORMAT_STARTTIME));
|
|
return dwRetval;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
|
|
case SCHED_TYPE_ONSTART:
|
|
case SCHED_TYPE_ONLOGON:
|
|
case SCHED_TYPE_ONIDLE:
|
|
|
|
if( dwStTimeOptCnt > 0 )
|
|
{
|
|
// Start Time is not applicable in this option.
|
|
//But the -starttime option specified. Display error.
|
|
ShowMessage(stderr,GetResString(IDS_STARTTIME_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Never comes here.
|
|
break;
|
|
}
|
|
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the start time specified by the user
|
|
|
|
Arguments:
|
|
|
|
[ in ] szEndTime : End time specified by user
|
|
[ in ] dwSchedType : Schedule type
|
|
[ in ] dwStTimeOptCnt : whether end time specified by the user or not
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
DWORD
|
|
ValidateEndTime(
|
|
IN LPWSTR szEndTime,
|
|
IN DWORD dwSchedType,
|
|
IN DWORD dwEndTimeOptCnt
|
|
)
|
|
{
|
|
|
|
DWORD dwRetval = RETVAL_SUCCESS; // return value
|
|
|
|
switch (dwSchedType)
|
|
{
|
|
case SCHED_TYPE_MINUTE:
|
|
case SCHED_TYPE_HOURLY:
|
|
case SCHED_TYPE_DAILY:
|
|
case SCHED_TYPE_WEEKLY:
|
|
case SCHED_TYPE_MONTHLY:
|
|
case SCHED_TYPE_ONETIME:
|
|
|
|
dwRetval = ValidateTimeString(szEndTime);
|
|
if( ( dwEndTimeOptCnt > 0 ) && ( RETVAL_FAIL == dwRetval) )
|
|
{
|
|
// Error. Invalid date string.
|
|
ShowMessage(stderr,GetResString(IDS_INVALIDFORMAT_ENDTIME));
|
|
return dwRetval;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
|
|
|
|
case SCHED_TYPE_ONSTART:
|
|
case SCHED_TYPE_ONLOGON:
|
|
case SCHED_TYPE_ONIDLE:
|
|
|
|
if( dwEndTimeOptCnt > 0 )
|
|
{
|
|
// Start Time is not applicable in this option.
|
|
//But the -endtime option specified. Display error.
|
|
ShowMessage(stderr,GetResString(IDS_ENDTIME_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// Never comes here.
|
|
break;
|
|
}
|
|
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the idle time specified by the user
|
|
|
|
Arguments:
|
|
|
|
[ in ] szIdleTime : Ilde time specified by user
|
|
[ in ] dwSchedType : Schedule type
|
|
[ in ] dwIdlTimeOptCnt : whether Idle time specified by the user
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateIdleTimeVal(
|
|
IN LPWSTR szIdleTime,
|
|
IN DWORD dwSchedType,
|
|
IN DWORD dwIdlTimeOptCnt
|
|
)
|
|
{
|
|
|
|
long lIdleTime = 0;
|
|
LPWSTR pszStopString = NULL;
|
|
switch (dwSchedType)
|
|
{
|
|
case SCHED_TYPE_MINUTE:
|
|
case SCHED_TYPE_HOURLY:
|
|
case SCHED_TYPE_DAILY:
|
|
case SCHED_TYPE_WEEKLY:
|
|
case SCHED_TYPE_MONTHLY:
|
|
case SCHED_TYPE_ONSTART:
|
|
case SCHED_TYPE_ONLOGON:
|
|
case SCHED_TYPE_ONETIME:
|
|
|
|
if( dwIdlTimeOptCnt > 0 )
|
|
{
|
|
ShowMessage(stderr ,GetResString(IDS_IDLETIME_NA));
|
|
return RETVAL_FAIL;
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case SCHED_TYPE_ONIDLE:
|
|
|
|
if( dwIdlTimeOptCnt == 0 )
|
|
{
|
|
|
|
ShowMessage(stderr,GetResString(IDS_NO_IDLETIME));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
lIdleTime = wcstoul(szIdleTime,&pszStopString,BASE_TEN);
|
|
if( ((pszStopString != NULL) && (StringLength( pszStopString, 0 ))) ||
|
|
(errno == ERANGE) ||( lIdleTime <= 0 ) || ( lIdleTime > 999 ) )
|
|
{
|
|
ShowMessage(stderr,GetResString(IDS_INVALIDORNO_IDLETIME));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ShowMessage(stderr,GetResString(IDS_INVALIDORNO_IDLETIME));
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the date string.
|
|
|
|
Arguments:
|
|
|
|
[ in ] szDate : Date string
|
|
[ in ] bStartDate : flag
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateDateString(
|
|
IN LPWSTR szDate,
|
|
IN BOOL bStartDate
|
|
)
|
|
{
|
|
WORD dwDate = 0;
|
|
WORD dwMon = 0;
|
|
WORD dwYear = 0;
|
|
WCHAR* szValues[1] = {NULL};//To pass to FormatMessage() API
|
|
WCHAR szFormat[MAX_DATE_STR_LEN] = L"\0";
|
|
//WCHAR szBuffer[MAX_RES_STRING] = L"\0";
|
|
|
|
if(StringLength(szDate, 0) <= 0)
|
|
{
|
|
if ( TRUE == bStartDate )
|
|
{
|
|
ShowMessage ( stderr, GetResString (IDS_STARTDATE_EMPTY) );
|
|
}
|
|
else
|
|
{
|
|
ShowMessage ( stderr, GetResString (IDS_DURATION_EMPTY) );
|
|
}
|
|
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if ( RETVAL_FAIL == GetDateFormatString( szFormat) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if( GetDateFieldEntities(szDate, &dwDate, &dwMon, &dwYear) ) // Error
|
|
{
|
|
szValues[0] = (WCHAR*) (szFormat);
|
|
if ( TRUE == bStartDate )
|
|
{
|
|
ShowMessageEx ( stderr, 1, FALSE, GetResString(IDS_INVALIDFORMAT_STARTDATE), _X(szFormat));
|
|
}
|
|
else
|
|
{
|
|
ShowMessageEx ( stderr, 1, FALSE, GetResString(IDS_INVALIDFORMAT_ENDDATE), _X(szFormat));
|
|
}
|
|
|
|
//ShowMessage(stderr, _X(szBuffer) );
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if( ValidateDateFields(dwDate, dwMon, dwYear) )
|
|
{
|
|
if ( TRUE == bStartDate )
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_STARTDATE) );
|
|
}
|
|
else
|
|
{
|
|
ShowMessage(stderr, GetResString(IDS_INVALID_ENDDATE) );
|
|
}
|
|
|
|
return RETVAL_FAIL;
|
|
|
|
}
|
|
|
|
return RETVAL_SUCCESS; // return success if no error.
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine retrives the date field entities out of the date string
|
|
|
|
Arguments:
|
|
|
|
[ in ] szDate : Date string
|
|
[ out ] pdwDate : Pointer to date value[1,2,3 ...30,31 etc]
|
|
[ out ] pdwMon : Pointer to Month value[1,2,3 ...12 etc]
|
|
[ out ] pdwYear : Pointer to year value[2000,3000 etc]
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
GetDateFieldEntities(
|
|
IN LPWSTR szDate,
|
|
OUT WORD* pdwDate,
|
|
OUT WORD* pdwMon,
|
|
OUT WORD* pdwYear
|
|
)
|
|
{
|
|
WCHAR strDate[MAX_STRING_LENGTH] = L"\0"; // Date in WCHAR type string.
|
|
WCHAR tDate[MAX_DATE_STR_LEN] = L"\0"; // Date
|
|
WCHAR tMon[MAX_DATE_STR_LEN] = L"\0"; // Month
|
|
WCHAR tYear[MAX_DATE_STR_LEN] = L"\0"; // Year
|
|
WORD wFormatID = 0;
|
|
|
|
if(szDate != NULL)
|
|
{
|
|
StringCopy(strDate, szDate, SIZE_OF_ARRAY(strDate));
|
|
}
|
|
|
|
if(StringLength(strDate, 0) <= 0)
|
|
return RETVAL_FAIL; // No value specified in szDate.
|
|
|
|
if ( RETVAL_FAIL == GetDateFieldFormat( &wFormatID ))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
if ( wFormatID == 0 || wFormatID == 1 )
|
|
{
|
|
if( (StringLength(strDate, 0) != DATESTR_LEN) ||
|
|
(strDate[FIRST_DATESEPARATOR_POS] != DATE_SEPARATOR_CHAR)
|
|
|| (strDate[SECOND_DATESEPARATOR_POS] != DATE_SEPARATOR_CHAR) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( (StringLength(strDate, 0) != DATESTR_LEN) ||
|
|
(strDate[FOURTH_DATESEPARATOR_POS] != DATE_SEPARATOR_CHAR)
|
|
|| (strDate[SEVENTH_DATESEPARATOR_POS] != DATE_SEPARATOR_CHAR) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
|
|
// Get the individual date field entities using wcstok function
|
|
// with respect to regional options.
|
|
|
|
|
|
if ( wFormatID == 0 )
|
|
{
|
|
StringCopy(tMon, wcstok(strDate,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tMon)); // Get the Month field.
|
|
if(StringLength(tMon, 0) > 0)
|
|
{
|
|
StringCopy(tDate, wcstok(NULL,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tDate)); // Get the date field.
|
|
StringCopy(tYear, wcstok(NULL,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tYear)); // Get the Year field.
|
|
}
|
|
}
|
|
else if ( wFormatID == 1 )
|
|
{
|
|
StringCopy(tDate, wcstok(strDate,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tDate)); // Get the Month field.
|
|
if(StringLength(tDate, 0) > 0)
|
|
{
|
|
StringCopy(tMon, wcstok(NULL,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tMon)); // Get the date field.
|
|
StringCopy(tYear, wcstok(NULL,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tYear)); // Get the Year field.
|
|
}
|
|
}
|
|
else
|
|
{
|
|
StringCopy(tYear, wcstok(strDate,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tYear)); // Get the Month field.
|
|
if(StringLength(tYear, 0) > 0)
|
|
{
|
|
StringCopy(tMon, wcstok(NULL,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tMon)); // Get the date field.
|
|
StringCopy(tDate, wcstok(NULL,DATE_SEPARATOR_STR), SIZE_OF_ARRAY(tDate)); // Get the Year field.
|
|
}
|
|
}
|
|
|
|
// Now convert string values to numeric for date validations.
|
|
LPWSTR pszStopString = NULL;
|
|
|
|
*pdwDate = (WORD)wcstoul(tDate,&pszStopString,BASE_TEN);
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
|
|
*pdwMon = (WORD)wcstoul(tMon,&pszStopString,BASE_TEN);
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
*pdwYear = (WORD)wcstoul(tYear,&pszStopString,BASE_TEN);
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the date field entities
|
|
|
|
Arguments:
|
|
|
|
[ in ] dwDate : Date value[Day in a month]
|
|
[ in ] dwMon : Month constant
|
|
[ in ] dwYear : year value
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateDateFields(
|
|
IN DWORD dwDate,
|
|
IN DWORD dwMon,
|
|
IN DWORD dwYear
|
|
)
|
|
{
|
|
|
|
if(dwYear <= MIN_YEAR || dwYear > MAX_YEAR)
|
|
return RETVAL_FAIL;
|
|
|
|
switch(dwMon)
|
|
{
|
|
case IND_JAN:
|
|
case IND_MAR:
|
|
case IND_MAY:
|
|
case IND_JUL:
|
|
case IND_AUG:
|
|
case IND_OCT:
|
|
case IND_DEC:
|
|
|
|
if(dwDate > 0 && dwDate <= 31)
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case IND_APR:
|
|
case IND_JUN:
|
|
case IND_SEP:
|
|
case IND_NOV:
|
|
|
|
if(dwDate > 0 && dwDate < 31)
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
break;
|
|
|
|
case IND_FEB:
|
|
|
|
if( ((dwYear % 4) == 0) && (dwDate > 0 && dwDate <= 29) )
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
else if( ((dwYear % 4) != 0) && (dwDate > 0 && dwDate < 29) )
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
}
|
|
|
|
return RETVAL_FAIL;
|
|
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the time specified by the user
|
|
|
|
Arguments:
|
|
|
|
[ in ] szTime : time string
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
******************************************************************************/
|
|
|
|
|
|
DWORD
|
|
ValidateTimeString(
|
|
IN LPWSTR szTime
|
|
)
|
|
{
|
|
WORD dwHours = 0;
|
|
WORD dwMins = 0;
|
|
//WORD dwSecs = 0 ;
|
|
|
|
// Check for the empty string value.
|
|
if(StringLength(szTime, 0) <= 0)
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
// Get separate entities from the given time string.
|
|
if( GetTimeFieldEntities(szTime, &dwHours, &dwMins ) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
// Validate the individual entities of the given time.
|
|
if( ValidateTimeFields( dwHours, dwMins ) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine retrieves the different fields of time
|
|
Arguments:
|
|
|
|
[ in ] szTime : Time string
|
|
[ out ] pdwHours : pointer to hours value
|
|
[ out ] pdwMins : pointer to mins value
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
GetTimeFieldEntities(
|
|
IN LPWSTR szTime,
|
|
OUT WORD* pdwHours,
|
|
OUT WORD* pdwMins
|
|
)
|
|
{
|
|
WCHAR strTime[MAX_STRING_LENGTH] = L"\0" ; // Time in WCHAR type string.
|
|
WCHAR tHours[MAX_TIME_STR_LEN] = L"\0" ; // Date
|
|
WCHAR tMins[MAX_TIME_STR_LEN] = L"\0" ; // Month
|
|
//WCHAR tSecs[MAX_TIME_STR_LEN] = L"\0" ; // Year
|
|
|
|
if(StringLength(szTime, 0) <= 0)
|
|
return RETVAL_FAIL;
|
|
|
|
StringCopy(strTime, szTime, SIZE_OF_ARRAY(strTime));
|
|
|
|
//
|
|
//Start Time accepts both HH:mm:ss and HH:mm formats even though seconds are of no use..
|
|
//This feature has been supported to be in sync with XP Professional.
|
|
//
|
|
if( ((StringLength(strTime, 0) != TIMESTR_LEN) && (StringLength(strTime, 0) != TIMESTR_OPT_LEN)) ||
|
|
((strTime[FIRST_TIMESEPARATOR_POS] != TIME_SEPARATOR_CHAR) && (strTime[SECOND_TIMESEPARATOR_POS] != TIME_SEPARATOR_CHAR)) )
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
// Get the individual Time field entities using wcstok function.in the order "hh" followed by "mm" followed by "ss"
|
|
StringCopy(tHours, wcstok(strTime,TIME_SEPARATOR_STR), SIZE_OF_ARRAY(tHours)); // Get the Hours field.
|
|
if(StringLength(tHours, 0) > 0)
|
|
{
|
|
StringCopy(tMins, wcstok(NULL,TIME_SEPARATOR_STR), SIZE_OF_ARRAY(tMins)); // Get the Minutes field.
|
|
}
|
|
|
|
LPWSTR pszStopString = NULL;
|
|
|
|
// Now convert string values to numeric for time validations.
|
|
*pdwHours = (WORD)wcstoul(tHours,&pszStopString,BASE_TEN);
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
*pdwMins = (WORD)wcstoul(tMins,&pszStopString,BASE_TEN);
|
|
if( (errno == ERANGE) ||
|
|
((pszStopString != NULL) && (StringLength( pszStopString, 0 ))))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the time fields of a given time
|
|
|
|
Arguments:
|
|
|
|
[ in ] dwHours :Hours value
|
|
[ in ] dwMins :Minutes value
|
|
[ in ] dwSecs : seconds value
|
|
|
|
Return Value :
|
|
A DWORD value indicating RETVAL_SUCCESS on success else
|
|
RETVAL_FAIL on failure
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
ValidateTimeFields(
|
|
IN DWORD dwHours,
|
|
IN DWORD dwMins
|
|
)
|
|
{
|
|
|
|
if ( dwHours <= HOURS_PER_DAY_MINUS_ONE )
|
|
{
|
|
if ( dwMins < MINUTES_PER_HOUR )
|
|
{
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
}
|
|
|
|
/******************************************************************************
|
|
Routine Description:
|
|
|
|
This routine validates the time fields of a given time
|
|
|
|
Arguments:
|
|
|
|
[ in ] szDay : time string
|
|
|
|
Return Value :
|
|
A WORD value containing the day constant [TASK_SUNDAY,TASK_MONDAY etc]
|
|
******************************************************************************/
|
|
|
|
WORD
|
|
GetTaskTrigwDayForDay(
|
|
IN LPWSTR szDay
|
|
)
|
|
{
|
|
WCHAR szDayBuff[MAX_RES_STRING] = L"\0";
|
|
WCHAR *token = NULL;
|
|
WCHAR seps[] = _T(" ,\n");
|
|
WORD dwRetval = 0;
|
|
SYSTEMTIME systime = {0,0,0,0,0,0,0,0};
|
|
|
|
if(StringLength(szDay, 0) != 0)
|
|
{
|
|
StringCopy(szDayBuff, szDay, SIZE_OF_ARRAY(szDayBuff));
|
|
}
|
|
|
|
// if /D is not specified.. set the default day to current day..
|
|
if( StringLength(szDayBuff, 0) <= 0 )
|
|
{
|
|
GetLocalTime (&systime);
|
|
|
|
switch ( systime.wDayOfWeek )
|
|
{
|
|
case 0:
|
|
return TASK_SUNDAY;
|
|
case 1:
|
|
return TASK_MONDAY;
|
|
case 2:
|
|
return TASK_TUESDAY;
|
|
case 3:
|
|
return TASK_WEDNESDAY;
|
|
case 4:
|
|
return TASK_THURSDAY;
|
|
case 5:
|
|
return TASK_FRIDAY;
|
|
case 6:
|
|
return TASK_SATURDAY;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
token = wcstok( szDayBuff, seps );
|
|
while( token != NULL )
|
|
{
|
|
if( !(StringCompare(token, GetResString( IDS_DAY_MODIFIER_SUN ), TRUE, 0)) )
|
|
dwRetval |= (TASK_SUNDAY);
|
|
else if( !(StringCompare(token, GetResString( IDS_DAY_MODIFIER_MON ), TRUE, 0)) )
|
|
dwRetval |= (TASK_MONDAY);
|
|
else if( !(StringCompare(token, GetResString( IDS_DAY_MODIFIER_TUE ), TRUE, 0)) )
|
|
dwRetval |= (TASK_TUESDAY);
|
|
else if( !(StringCompare(token, GetResString( IDS_DAY_MODIFIER_WED ), TRUE, 0)) )
|
|
dwRetval |= (TASK_WEDNESDAY);
|
|
else if( !(StringCompare(token, GetResString( IDS_DAY_MODIFIER_THU ), TRUE, 0)) )
|
|
dwRetval |= (TASK_THURSDAY);
|
|
else if( !(StringCompare(token,GetResString( IDS_DAY_MODIFIER_FRI ), TRUE, 0)) )
|
|
dwRetval |= (TASK_FRIDAY);
|
|
else if( !(StringCompare(token, GetResString( IDS_DAY_MODIFIER_SAT ), TRUE, 0)) )
|
|
dwRetval |= (TASK_SATURDAY);
|
|
else if( !(StringCompare(token, ASTERIX, TRUE, 0)) )
|
|
return (TASK_SUNDAY | TASK_MONDAY | TASK_TUESDAY | TASK_WEDNESDAY |
|
|
TASK_THURSDAY | TASK_FRIDAY | TASK_SATURDAY);
|
|
else
|
|
return 0;
|
|
|
|
token = wcstok( NULL, seps );
|
|
}
|
|
|
|
return dwRetval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
|
|
Routine Description:
|
|
|
|
This routine validates the time fields of a given time
|
|
|
|
Arguments:
|
|
|
|
[ in ] szMonth : Month string
|
|
|
|
Return Value :
|
|
A WORD value containing the Month constant
|
|
[TASK_JANUARY,TASK_FEBRUARY etc]
|
|
|
|
******************************************************************************/
|
|
|
|
WORD
|
|
GetTaskTrigwMonthForMonth(
|
|
IN LPWSTR szMonth
|
|
)
|
|
{
|
|
WCHAR *token = NULL;
|
|
WORD dwRetval = 0;
|
|
WCHAR strMon[MAX_TOKENS_LENGTH] = L"\0";
|
|
WCHAR seps[] = _T(" ,\n");
|
|
|
|
if( StringLength(szMonth, 0) <= 0 )
|
|
{
|
|
return (TASK_JANUARY | TASK_FEBRUARY | TASK_MARCH | TASK_APRIL | TASK_MAY | TASK_JUNE |
|
|
TASK_JULY | TASK_AUGUST | TASK_SEPTEMBER | TASK_OCTOBER
|
|
| TASK_NOVEMBER | TASK_DECEMBER );
|
|
}
|
|
|
|
StringCopy(strMon, szMonth, SIZE_OF_ARRAY(strMon));
|
|
|
|
token = wcstok( szMonth, seps );
|
|
while( token != NULL )
|
|
{
|
|
if( !(StringCompare(token, ASTERIX, TRUE, 0)) )
|
|
return (TASK_JANUARY | TASK_FEBRUARY | TASK_MARCH | TASK_APRIL
|
|
| TASK_MAY | TASK_JUNE | TASK_JULY | TASK_AUGUST | TASK_SEPTEMBER | TASK_OCTOBER
|
|
| TASK_NOVEMBER | TASK_DECEMBER );
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_JAN ), TRUE, 0)) )
|
|
dwRetval |= (TASK_JANUARY);
|
|
else if( !(StringCompare(token,GetResString( IDS_MONTH_MODIFIER_FEB ), TRUE, 0)) )
|
|
dwRetval |= (TASK_FEBRUARY);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_MAR ), TRUE, 0)) )
|
|
dwRetval |= (TASK_MARCH);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_APR ), TRUE, 0)) )
|
|
dwRetval |= (TASK_APRIL);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_MAY ), TRUE, 0)) )
|
|
dwRetval |= (TASK_MAY);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_JUN ), TRUE, 0)) )
|
|
dwRetval |= (TASK_JUNE);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_JUL ), TRUE, 0)) )
|
|
dwRetval |= (TASK_JULY);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_AUG ), TRUE, 0)) )
|
|
dwRetval |= (TASK_AUGUST);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_SEP ), TRUE, 0)) )
|
|
dwRetval |= (TASK_SEPTEMBER);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_OCT ), TRUE, 0)) )
|
|
dwRetval |= (TASK_OCTOBER);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_NOV ), TRUE, 0)) )
|
|
dwRetval |= (TASK_NOVEMBER);
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_DEC ), TRUE, 0)) )
|
|
dwRetval |= (TASK_DECEMBER);
|
|
else
|
|
return 0;
|
|
|
|
token = wcstok( NULL, seps );
|
|
}
|
|
|
|
return dwRetval;
|
|
}
|
|
|
|
/******************************************************************************
|
|
|
|
Routine Description:
|
|
|
|
This routine returns the corresponding month flag
|
|
|
|
Arguments:
|
|
|
|
[ in ] dwMonthId : Month index
|
|
|
|
Return Value :
|
|
A WORD value containing the Month constant
|
|
[TASK_JANUARY,TASK_FEBRUARY etc]
|
|
|
|
******************************************************************************/
|
|
|
|
WORD
|
|
GetMonthId(
|
|
IN DWORD dwMonthId
|
|
)
|
|
{
|
|
DWORD dwMonthsArr[] = {TASK_JANUARY,TASK_FEBRUARY ,TASK_MARCH ,TASK_APRIL ,
|
|
TASK_MAY ,TASK_JUNE ,TASK_JULY ,TASK_AUGUST,
|
|
TASK_SEPTEMBER ,TASK_OCTOBER ,TASK_NOVEMBER ,TASK_DECEMBER } ;
|
|
|
|
DWORD wMonthFlags = 0;
|
|
DWORD dwMod = 0;
|
|
|
|
dwMod = dwMonthId - 1;
|
|
|
|
while(dwMod < 12)
|
|
{
|
|
wMonthFlags |= dwMonthsArr[dwMod];
|
|
dwMod = dwMod + dwMonthId;
|
|
}
|
|
|
|
return (WORD)wMonthFlags;
|
|
}
|
|
|
|
/******************************************************************************
|
|
|
|
Routine Description:
|
|
|
|
This routine returns the maximum Last day in the months specifed
|
|
|
|
Arguments:
|
|
|
|
[ in ] szMonths : string containing months specified by user
|
|
[ in ] wStartYear : string containing start year
|
|
Return Value :
|
|
A DWORD value specifying the maximum last day in the specified months
|
|
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
GetNumDaysInaMonth(
|
|
IN WCHAR* szMonths,
|
|
IN WORD wStartYear
|
|
)
|
|
{
|
|
DWORD dwDays = 31;//max.no of days in a month
|
|
BOOL bMaxDays = FALSE;//if any of the months have 31 then days of value 31 is returned
|
|
|
|
if( ( StringLength(szMonths, 0) == 0 ) || ( StringCompare(szMonths,ASTERIX, TRUE, 0) == 0 ) )
|
|
return dwDays; //All months[default]
|
|
|
|
|
|
WCHAR *token = NULL;
|
|
WCHAR strMon[MAX_MONTH_STR_LEN] = L"\0";
|
|
WCHAR seps[] = _T(" ,\n");
|
|
|
|
StringCopy(strMon, szMonths, SIZE_OF_ARRAY(strMon));
|
|
|
|
token = wcstok( strMon, seps );
|
|
while( token != NULL )
|
|
{
|
|
if( !(StringCompare(token,GetResString( IDS_MONTH_MODIFIER_FEB ), TRUE, 0)) )
|
|
{
|
|
|
|
if( ( (wStartYear % 400) == 0) ||
|
|
( ( (wStartYear % 4) == 0) &&
|
|
( (wStartYear % 100) != 0) ) )
|
|
{
|
|
dwDays = 29;
|
|
}
|
|
else
|
|
{
|
|
dwDays = 28;
|
|
}
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_JAN ), TRUE, 0)) )
|
|
{
|
|
bMaxDays = TRUE;
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_MAR ), TRUE, 0)) )
|
|
{
|
|
bMaxDays = TRUE;
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_MAY ), TRUE, 0)) )
|
|
{
|
|
bMaxDays = TRUE;
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_JUL ), TRUE, 0)) )
|
|
{
|
|
bMaxDays = TRUE;
|
|
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_AUG ), TRUE, 0)) )
|
|
{
|
|
bMaxDays = TRUE;
|
|
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_OCT ), TRUE, 0)) )
|
|
{
|
|
bMaxDays = TRUE;
|
|
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_DEC ), TRUE, 0)) )
|
|
{
|
|
bMaxDays = TRUE;
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_APR ), TRUE, 0)) )
|
|
{
|
|
dwDays = 30;
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_JUN ), TRUE, 0)) )
|
|
{
|
|
dwDays = 30;
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_SEP ), TRUE, 0)) )
|
|
{
|
|
dwDays = 30;
|
|
}
|
|
else if( !(StringCompare(token, GetResString( IDS_MONTH_MODIFIER_NOV ), TRUE, 0)) )
|
|
{
|
|
dwDays = 30;
|
|
}
|
|
|
|
|
|
token = wcstok( NULL, seps );
|
|
}
|
|
|
|
if (bMaxDays == TRUE)
|
|
{
|
|
return 31;
|
|
}
|
|
else
|
|
{
|
|
return dwDays;
|
|
}
|
|
|
|
}
|
|
|
|
/******************************************************************************
|
|
|
|
Routine Description:
|
|
|
|
This routine checks the validates the taskname of the task to be created.
|
|
|
|
Arguments:
|
|
|
|
[ in ] pszJobName : Pointer to the job[task] name
|
|
|
|
Return Value :
|
|
If valid task name then TRUE else FALSE
|
|
|
|
******************************************************************************/
|
|
|
|
BOOL
|
|
VerifyJobName(
|
|
IN WCHAR* pszJobName
|
|
)
|
|
{
|
|
WCHAR szTokens[] = {_T('<'),_T('>'),_T(':'),_T('/'),_T('\\'),_T('|')};
|
|
|
|
if( wcspbrk(pszJobName,szTokens) == NULL)
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
|
|
Routine Description:
|
|
|
|
This routine gets the date format value with respective to regional options.
|
|
|
|
Arguments:
|
|
|
|
[ out ] pdwFormat : Date format value.
|
|
|
|
Return Value :
|
|
Returns RETVAL_FAIL on failure and RETVAL_SUCCESS on success.
|
|
|
|
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
GetDateFieldFormat(
|
|
OUT WORD* pwFormat
|
|
)
|
|
{
|
|
LCID lcid;
|
|
WCHAR szBuffer[MAX_BUF_SIZE];
|
|
|
|
//Get the user default locale in the users computer
|
|
lcid = GetUserDefaultLCID();
|
|
|
|
//Get the date format
|
|
if (GetLocaleInfo(lcid, LOCALE_IDATE, szBuffer, MAX_BUF_SIZE))
|
|
{
|
|
switch (szBuffer[0])
|
|
{
|
|
case TEXT('0'):
|
|
*pwFormat = 0;
|
|
break;
|
|
case TEXT('1'):
|
|
*pwFormat = 1;
|
|
break;
|
|
case TEXT('2'):
|
|
*pwFormat = 2;
|
|
break;
|
|
default:
|
|
return RETVAL_FAIL;
|
|
}
|
|
}
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
|
|
Routine Description:
|
|
|
|
This routine gets the date format string with respective to regional options.
|
|
|
|
Arguments:
|
|
|
|
[ out ] szFormat : Date format string.
|
|
|
|
Return Value :
|
|
Returns RETVAL_FAIL on failure and RETVAL_SUCCESS on success.
|
|
|
|
******************************************************************************/
|
|
|
|
DWORD
|
|
GetDateFormatString(
|
|
IN LPWSTR szFormat
|
|
)
|
|
{
|
|
WORD wFormatID = 0;
|
|
|
|
if ( RETVAL_FAIL == GetDateFieldFormat( &wFormatID ))
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
|
|
if ( wFormatID == 0 )
|
|
{
|
|
StringCopy (szFormat, GetResString(IDS_MMDDYY_FORMAT), MAX_STRING_LENGTH);
|
|
}
|
|
else if ( wFormatID == 1 )
|
|
{
|
|
StringCopy (szFormat, GetResString( IDS_DDMMYY_FORMAT), MAX_STRING_LENGTH);
|
|
}
|
|
else if ( wFormatID == 2 )
|
|
{
|
|
StringCopy (szFormat, GetResString(IDS_YYMMDD_FORMAT), MAX_STRING_LENGTH);
|
|
}
|
|
else
|
|
{
|
|
return RETVAL_FAIL;
|
|
}
|
|
|
|
return RETVAL_SUCCESS;
|
|
}
|
|
|