windows-server-2003/net/rras/cm/cmsetup/processcmdln.cpp

//+----------------------------------------------------------------------------
//
// File:     processcmdln.cpp
//
// Module:   CMSETUP.LIB
//
// Synopsis: Implementation of the CProcessCmdLn class.
//
// Copyright (c) 1998-1999 Microsoft Corporation
//
// Author:   quintinb       Created Header      08/19/99
//
//+----------------------------------------------------------------------------
#include "cmsetup.h"
#include "setupmem.h"

//+----------------------------------------------------------------------------
//
// Function:  CProcessCmdLn::CProcessCmdLn
//
// Synopsis:  Inits the class by copying the valid command line switches to the
//            command line switch array.
//
// Arguments: UINT NumSwitches - Number of switches in the array
//            UINT NumCharsInSwitch - Number of chars in each switch, counting the terminating NULL
//            TCHAR pszCommandLineSwitches[][] - Array of command line switches.
//
// Returns:   Nothing
//
// History:   quintinb  Created     7/24/98
//
//+----------------------------------------------------------------------------
CProcessCmdLn::CProcessCmdLn(UINT NumSwitches, ArgStruct* pArrayOfArgStructs, 
							 BOOL bSkipFirstToken, BOOL bBlankCmdLnOkay)
{
    m_NumSwitches = NumSwitches;
    m_bSkipFirstToken = bSkipFirstToken;
    m_bBlankCmdLnOkay = bBlankCmdLnOkay;
    m_CommandLineSwitches = NULL;

    m_CommandLineSwitches = (ArgStruct*)CmMalloc(m_NumSwitches*sizeof(ArgStruct));

    if (m_CommandLineSwitches)
    {
        for(UINT i =0; i < NumSwitches; i++)
        {
            m_CommandLineSwitches[i].pszArgString = 
                (TCHAR*)CmMalloc(sizeof(TCHAR)*(lstrlen(pArrayOfArgStructs[i].pszArgString) + 1));

            if (m_CommandLineSwitches[i].pszArgString)
            {
                lstrcpyn(m_CommandLineSwitches[i].pszArgString, 
                    pArrayOfArgStructs[i].pszArgString, 
                    (lstrlen(pArrayOfArgStructs[i].pszArgString) + 1));

                m_CommandLineSwitches[i].dwFlagModifier = pArrayOfArgStructs[i].dwFlagModifier;
            }
        }
    }
}

//+----------------------------------------------------------------------------
//
// Function:  CProcessCmdLn::~CProcessCmdLn
//
// Synopsis:  Cleans up after the class by deleting the dynamically allocated
//            string.
//
// Arguments: None
//
// Returns:   Nothing
//
// History:   Created Header    7/24/98
//
//+----------------------------------------------------------------------------
CProcessCmdLn::~CProcessCmdLn()
{
    if (m_CommandLineSwitches)
    {
        for(UINT i =0; i < m_NumSwitches; i++)
        {
            CmFree(m_CommandLineSwitches[i].pszArgString);			
        }
        CmFree(m_CommandLineSwitches);
    }
}


//+----------------------------------------------------------------------------
//
// Function:  CProcessCmdLn::IsValidSwitch
//
// Synopsis:  This function tells whether the inputed switch is a recognized
//            command line switch.
//
// Arguments: LPCTSTR pszSwitch - Input switch string to be tested
//
// Returns:   BOOL - Returns TRUE if the switch passed in is recognized as valid
//
// History:   quintinb Created    7/13/98
//
//+----------------------------------------------------------------------------
BOOL CProcessCmdLn::IsValidSwitch(LPCTSTR pszSwitch, LPDWORD pdwFlags)
{
    for (UINT i = 0; i < m_NumSwitches; i++)
    {
        if (m_CommandLineSwitches[i].pszArgString && (0 == lstrcmpi(m_CommandLineSwitches[i].pszArgString, pszSwitch)))
        {
            //
            //  Then we have a match
            //
            *pdwFlags |= m_CommandLineSwitches[i].dwFlagModifier;
            return TRUE;
        }
    }

    return FALSE;
}

//+----------------------------------------------------------------------------
//
// Function:  CProcessCmdLn::IsValidFilePath
//
// Synopsis:  This file checks to see if the inputted file path is a valid filepath.
//            This function depends on setfileattributes.
//
// Arguments: LPCTSTR pszFile - File to check to see if it exists.
//
// Returns:   BOOL - Returns TRUE if we can set the attributes of the file inputed.
//
// History:   quintinb Created   7/13/98
//
//+----------------------------------------------------------------------------
BOOL CProcessCmdLn::IsValidFilePath(LPCTSTR pszFile)
{
     return SetFileAttributes(pszFile, FILE_ATTRIBUTE_NORMAL);
}



//+----------------------------------------------------------------------------
//
// Function:  CProcessCmdLn::EnsureFullFilePath
//
// Synopsis:  This file checks to see if a file path passed in is a full path.
//            If it is not a full path then it adds the current directory path
//            to the beginning (assuming that we have a filename and extension).
//
// Arguments: LPTSTR pszFile - File to check
//            UINT uNumChars - Number of chars in the buffer holding pszFile
//
// Returns:   BOOL - TRUE if a full file path
//
// History:   quintinb  Created    7/24/98
//
//+----------------------------------------------------------------------------
BOOL CProcessCmdLn::EnsureFullFilePath(LPTSTR pszFile, UINT uNumChars)
{
    BOOL bReturn = FALSE;

    if (SetFileAttributes(pszFile, FILE_ATTRIBUTE_NORMAL))
    {
        CFileNameParts InstallFileParts(pszFile);

        if ((TEXT('\0') == InstallFileParts.m_Drive[0]) && 
            (TEXT('\0') == InstallFileParts.m_Dir[0]) &&
            (TEXT('\0') != InstallFileParts.m_FileName[0]) &&
            (TEXT('\0') != InstallFileParts.m_Extension[0]))
        {
            //
            //  Then we have a filename and extension but we don't
            //  have a full path.  Thus we want to add the current
            //  directory onto the filename and extension.
            //
            TCHAR szTemp[MAX_PATH+1];

            if (GetCurrentDirectory(MAX_PATH, szTemp))
            {
                if (uNumChars > (UINT)(lstrlen(szTemp) + lstrlen(InstallFileParts.m_FileName) + lstrlen(InstallFileParts.m_Extension) + 2))
                {
                    wsprintf(pszFile, TEXT("%s\\%s%s"), szTemp, InstallFileParts.m_FileName, InstallFileParts.m_Extension);
                    bReturn = TRUE;
                }
            }
        }
        else
        {
            //
            //  Could be a UNC path, a path with a drive letter and filename, or
            //  a full path with a drive and a dir
            //
            bReturn = TRUE;
        }
    }

    return bReturn;
}




//+----------------------------------------------------------------------------
//
// Function:  CProcessCmdLn::CheckIfValidSwitchOrPath
//
// Synopsis:  Bundles code to determine if a token is a valid switch or path.
//
// Arguments: LPCTSTR pszToken - current token
//            BOOL* pbFoundSwitch - pointer to the BOOL which tells if a switch has been found yet
//            BOOL* pbFoundPath - pointer to the BOOL which tells if a path has been found yet
//            LPTSTR pszSwitch - string to hold the switch
//            LPTSTR pszPath - string to hold the path
//
// Returns:   BOOL - returns TRUE if successful
//
// History:   quintinb Created    8/25/98
//
//+----------------------------------------------------------------------------
BOOL CProcessCmdLn::CheckIfValidSwitchOrPath(LPCTSTR pszToken, LPDWORD pdwFlags, 
                              BOOL* pbFoundPath, LPTSTR pszPath)
{
    if (IsValidSwitch(pszToken, pdwFlags))
    {
        CMTRACE1(TEXT("ProcessCmdLn - ValidSwitch is %s"), pszToken);
    }
    else if (!(*pbFoundPath))
    {
        if (IsValidFilePath(pszToken))
        {
            *pbFoundPath = TRUE;
            lstrcpy(pszPath, pszToken);

            CMTRACE1(TEXT("ProcessCmdLn - ValidFilePath is %s"), pszToken);
        }
        else
        {
            //
            //  Maybe the path contains environment variables, try to expand them.
            //
            TCHAR szExpandedPath[MAX_PATH+1] = TEXT("");

            CMTRACE1(TEXT("ProcessCmdLn - %s is not a valid path, expanding environment strings"), pszToken);
            
            ExpandEnvironmentStrings(pszToken, szExpandedPath, MAX_PATH);

            CMTRACE1(TEXT("ProcessCmdLn - expanded path is %s"), szExpandedPath);
                        
            if (IsValidFilePath(szExpandedPath))
            {
                *pbFoundPath = TRUE;
                lstrcpy(pszPath, szExpandedPath);
            }
            else
            {
                //
                //  Still no luck, return an error
                //
                CMTRACE1(TEXT("ProcessCmdLn - %s is not a valid path"), szExpandedPath);

                return FALSE;
            }
        }
    }
    else
    {
        //
        //  We don't know what this is, send back an error
        //
        CMTRACE1(TEXT("ProcessCmdLn - Invalid token is %s"), pszToken);
        
        return FALSE;                    
    }

    return TRUE;
}


//+----------------------------------------------------------------------------
//
// Function:  CProcessCmdLn::GetCmdLineArgs
//
// Synopsis:  This function looks for any combination of just a command line 
//            switch, just a path, or both.  Handles long paths if quoted. 
//              
//
// Arguments: IN LPTSTR pszCmdln - the command line to parse 
//            OUT LPTSTR pszSwitch - Out parameter for the command line switch
//            OUT LPTSTR pszPath -  Out parameter for the path
//
// Returns:   BOOL - Returns TRUE if it was able to parse the args
//
//  History:    quintinb    rewrote InitArgs from cmmgr.cpp to make it
//                          simpler and more taylored to cmstp.     7-13-98
//              
//----------------------------------------------------------------------------
BOOL CProcessCmdLn::GetCmdLineArgs(IN LPTSTR pszCmdln, OUT LPDWORD pdwFlags, OUT LPTSTR pszPath, 
					UINT uPathStrLimit)
{
    LPTSTR  pszCurr;
    LPTSTR  pszToken;
    CMDLN_STATE state;
    BOOL bFoundSwitch = FALSE;
    BOOL bFoundPath = FALSE;

	if ((NULL == pdwFlags) || (NULL == pszPath))
	{
		return FALSE;
	}

	//
	//	Init pdwFlags to Zero
	//
	*pdwFlags = 0;

	//
	//	If m_bSkipFirstToken is TRUE, the we will skip the first Token.  Otherwise,
	//  we won't.
	//
    BOOL bFirstToken = m_bSkipFirstToken;
	
    state = CS_CHAR;
    pszCurr = pszToken = pszCmdln;

    CMTRACE1(TEXT("CProcessCmdLn::GetCmdLineArgs - Command line is %s"), pszCmdln);

    do
    {
        switch (*pszCurr)
        {
            case TEXT(' '):
                if (state == CS_CHAR)
                {
                    //
                    // we found a token
                    //

                    *pszCurr = TEXT('\0');
                    if (bFirstToken)
                    {
                        //
                        //  The first token is the name of the exe, thus throw it away
                        //
                        bFirstToken = FALSE;
                        CMTRACE1(TEXT("Throwing away, first token: %s"), pszToken);
                    }
                    else if(!CheckIfValidSwitchOrPath(pszToken, pdwFlags, &bFoundPath, 
                             pszPath))
                    {
                        //
                        //  return an error
                        //
                        return FALSE;
                    }
                 
                    *pszCurr = TEXT(' ');
                    pszCurr = pszToken = CharNext(pszCurr);
                    state = CS_END_SPACE;
                    continue;
                }
                else if (state == CS_END_SPACE || state == CS_END_QUOTE)
                {
                    pszToken = CharNext(pszToken);
                }
                break;

            case TEXT('\"'):
                if (state == CS_BEGIN_QUOTE)
                {
                    //
                    // we found a token
                    //
                    *pszCurr = TEXT('\0');

                    //
                    // skip the opening quote
                    //
                    pszToken = CharNext(pszToken);
                    if (bFirstToken)
                    {
                        //
                        //  The first token is the name of the exe, thus throw it away
                        //
                        bFirstToken = FALSE;
                        CMTRACE1(TEXT("Throwing away, first token: %s"), pszToken);
                    }
                    else if(!CheckIfValidSwitchOrPath(pszToken, pdwFlags, &bFoundPath, 
                             pszPath))
                    {
                        //
                        //  return an error
                        //
                        return FALSE;
                    }
                    
                    *pszCurr = TEXT('\"');
                    pszCurr = pszToken = CharNext(pszCurr);
                    state = CS_END_QUOTE;
                    continue;
                }
                else
                {
                    state = CS_BEGIN_QUOTE;
                }
                break;

            case TEXT('\0'):
                if (state != CS_END_QUOTE)
                {
                    if (bFirstToken)
                    {
                        //
                        //  The first token is the name of the exe, thus throw it away
                        //
                        bFirstToken = FALSE;
                        CMTRACE1(TEXT("Throwing away, first token: %s"), pszToken);
                    }
                    else if(!CheckIfValidSwitchOrPath(pszToken, pdwFlags, &bFoundPath, 
                             pszPath))
                    {
                        //
                        //  return an error
                        //
                        return FALSE;
                    }
                }
                state = CS_DONE;
                break;

            default:
                if (state == CS_END_SPACE || state == CS_END_QUOTE)
                {
                    state = CS_CHAR;
                }
                break;
        }
        
        pszCurr = CharNext(pszCurr);
    } while (state != CS_DONE);


    if (bFoundPath)
    {
        //
        //  Then at least we found a path (and maybe switches, maybe not)
        //
        return EnsureFullFilePath(pszPath, uPathStrLimit);
    }
    else if (0 != *pdwFlags)
    {
        //
        //  Then at least we found a switch
        //
        return TRUE;
    }
    else
    {
		//
		//	If it is okay to have a blank command line, then this is okay, otherwise it isn't.
		//  Note that if m_bSkipFirstToken == TRUE, then the command line might not be completely
		//  blank, it could contain the name of the executable for instance.
		//
		return m_bBlankCmdLnOkay;
    }
}