windows-server-2003/admin/cmdline/scheduledtasks/createvalidations.cpp

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

    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;
}