/*++

 Copyright (c) 2000-2001 Microsoft Corporation

 Module Name:

    CorrectPathChangesBase.cpp

 Abstract:
    Several paths were changed between Win9x and WinNT.  This routine defines
    the CorrectPathChangesBase routines that is called with a Win9x path and returns
    the corresponding WinNT path.

 History:

    03-Mar-00   robkenny        Converted CorrectPathChanges.cpp to this class.
    21-Mar-00   robkenny        StringISub("abc", "abcd") now works
    06/20/2000  robkenny        EnvironmentValues::Initialize now checks the return status of the system calls
    12/12/2000  mnikkel         Some apps look for ddhelp.exe to exist to confirm directx is installed,
                                set this to look for ddraw.dll since ddhelp.exe no longer exists in directx.
    02/13/2001  robkenny/a-larrsh Added AllProfile and UserProfile to EnvironmentValues
    03/22/2001  robkenny        Do not redirect files to directories that the user does not have permission.
    08/14/2001  robkenny        Moved code inside the ShimLib namespace.
    

--*/
#include "ClassCFP.h"
#include "StrSafe.h"
#include "Userenv.h"
#include <stdio.h>


namespace ShimLib
{


WCHAR *
ReplaceAllStringsAllocW(const WCHAR * lpOrig,
                        const VectorT<StringPairW> & pathFixes)
{
    CSTRING_TRY
    {
        CString csReplaced(lpOrig);


        for (DWORD i = 0; i < pathFixes.Size(); ++i)
        {
            const StringPairW & stringPair = pathFixes[i];

            // Attempt a string substitution
            csReplaced.ReplaceI(stringPair.lpOld, stringPair.lpNew);
        }

        // Wasteful, but all calling routines expect ownership of the return value.
        return StringDuplicateW(csReplaced);
    }
    CSTRING_CATCH
    {
        // Fall thru
    }

    return NULL;
}

//-------------------------------------------------------------------------------------------------------------

EnvironmentValues::EnvironmentValues()
{
    bInitialized = FALSE;
}

EnvironmentValues::~EnvironmentValues()
{
    // Clear the list
    Erase();
}

// Given an CLSIDL, create an environment variable and its two variants
// CSIDL_WINDOWS would add c:\windows, \windows and windows
void EnvironmentValues::Add_Variants(const WCHAR * lpEnvName, const WCHAR * lpEnvValue, eAddNameEnum addName, eAddNoDLEnum noDL)
{
    CSTRING_TRY
    {
        CString csEnvName;
        CString csEnvValue(lpEnvValue);

        csEnvName.Format(L"%%%s%%", lpEnvName);
        AddEnvironmentValue(csEnvName, csEnvValue);

        // Remove the drive letter and the colon.
        if (noDL == eAddNoDL)
        {
            CString csNoDL(csEnvValue);
            csNoDL.Delete(0, 2);

            csEnvName.Format(L"%%%s_NODL%%", lpEnvName);
            AddEnvironmentValue(csEnvName, csNoDL);
        }

        // Use the last path component as the name.
        if (addName == eAddName)
        {
            CString csName;
            csEnvValue.GetLastPathComponent(csName);

            csEnvName.Format(L"%%%s_NAME%%", lpEnvName);
            AddEnvironmentValue(csEnvName, csName);
        }
    }
    CSTRING_CATCH
    {
        // Do Nothing
    }
}

// Given an CLSIDL, create an environment variable and its two variants
// CSIDL_WINDOWS would add c:\windows, \windows and windows
void EnvironmentValues::Add_CSIDL(const WCHAR * lpEnvName, int nFolder, eAddNameEnum addName, eAddNoDLEnum noDL)
{
    CSTRING_TRY
    {
        CString csPath;
        SHGetSpecialFolderPathW(csPath, nFolder);

        if (csPath.GetLength() > 0)
        {
            Add_Variants(lpEnvName, csPath, addName, noDL);
        }
    }
    CSTRING_CATCH
    {
        // Do Nothing
    }
}

// Add all _CSIDL values as environment variables.
void EnvironmentValues::AddAll_CSIDL()
{
    Add_CSIDL(L"CSIDL_APPDATA",                 CSIDL_APPDATA,                  eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_ADMINTOOLS",       CSIDL_COMMON_ADMINTOOLS,        eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_APPDATA",          CSIDL_COMMON_APPDATA,           eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_DESKTOPDIRECTORY", CSIDL_COMMON_DESKTOPDIRECTORY,  eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_DOCUMENTS",        CSIDL_COMMON_DOCUMENTS,         eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_FAVORITES",        CSIDL_COMMON_FAVORITES,         eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_MUSIC",            CSIDL_COMMON_MUSIC,             eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_PICTURES",         CSIDL_COMMON_PICTURES,          eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_PROGRAMS",         CSIDL_COMMON_PROGRAMS,          eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_STARTMENU",        CSIDL_COMMON_STARTMENU,         eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_STARTUP",          CSIDL_COMMON_STARTUP,           eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COMMON_TEMPLATES",        CSIDL_COMMON_TEMPLATES,         eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_COOKIES",                 CSIDL_COOKIES,                  eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_DESKTOPDIRECTORY",        CSIDL_DESKTOPDIRECTORY,         eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_FAVORITES",               CSIDL_FAVORITES,                eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_FONTS",                   CSIDL_FONTS,                    eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_HISTORY",                 CSIDL_HISTORY,                  eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_INTERNET_CACHE",          CSIDL_INTERNET_CACHE,           eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_LOCAL_APPDATA",           CSIDL_LOCAL_APPDATA,            eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_MYMUSIC",                 CSIDL_MYMUSIC,                  eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_MYPICTURES",              CSIDL_MYPICTURES,               eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_NETHOOD",                 CSIDL_NETHOOD,                  eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_PERSONAL",                CSIDL_PERSONAL,                 eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_PRINTHOOD",               CSIDL_PRINTHOOD,                eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_PROFILE",                 CSIDL_PROFILE,                  eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_PROGRAM_FILES",           CSIDL_PROGRAM_FILES,            eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_PROGRAM_FILES_COMMON",    CSIDL_PROGRAM_FILES_COMMON,     eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_PROGRAMS",                CSIDL_PROGRAMS,                 eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_RECENT",                  CSIDL_RECENT,                   eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_SENDTO",                  CSIDL_SENDTO,                   eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_STARTMENU",               CSIDL_STARTMENU,                eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_STARTUP",                 CSIDL_STARTUP,                  eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_SYSTEM",                  CSIDL_SYSTEM,                   eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_TEMPLATES",               CSIDL_TEMPLATES,                eAddName, eAddNoDL);
    Add_CSIDL(L"CSIDL_WINDOWS",                 CSIDL_WINDOWS,                  eAddName, eAddNoDL);
}

void EnvironmentValues::Initialize()
{
    if (bInitialized == FALSE)
    {
        bInitialized = TRUE;

        WCHAR   lpDir[MAX_PATH];
        DWORD   dwSize;
        HRESULT result;
        DWORD   dwChars;
        BOOL    bResult;

        dwChars = GetWindowsDirectoryW(lpDir, MAX_PATH);
        if (dwChars > 0 && dwChars <= MAX_PATH)
        {
            AddEnvironmentValue( L"%WinDir%", lpDir );
            AddEnvironmentValue( L"%SystemRoot%", lpDir );

            lpDir[2] = 0;
            AddEnvironmentValue( L"%SystemDrive%", lpDir );
        }

        dwChars = GetSystemDirectoryW( lpDir, MAX_PATH);
        if (dwChars > 0 && dwChars <= MAX_PATH)
        {
            AddEnvironmentValue( L"%SystemDir%", lpDir );
        }

        dwSize = ARRAYSIZE(lpDir);
        bResult = GetUserNameW(lpDir, &dwSize);
        if (bResult)
        {
            AddEnvironmentValue( L"%Username%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_PROGRAM_FILES, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%ProgramFiles%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_STARTMENU, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%UserStartMenu%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_COMMON_STARTMENU, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%AllStartMenu%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_DESKTOPDIRECTORY, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%UserDesktop%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_COMMON_DESKTOPDIRECTORY, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%AllDesktop%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_FAVORITES, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%UserFavorites%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_COMMON_FAVORITES, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%AllFavorites%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%UserAppData%", lpDir );
        }

        result = SHGetFolderPathW( NULL, CSIDL_COMMON_APPDATA, NULL, SHGFP_TYPE_DEFAULT, lpDir );
        if (SUCCEEDED(result))
        {
            AddEnvironmentValue( L"%AllAppData%", lpDir );
        }


        // C:\Documents and Settings\All Users 
        dwSize = ARRAYSIZE(lpDir);
        bResult = GetAllUsersProfileDirectoryW(lpDir, &dwSize);
        if (bResult)
        {
            Add_Variants( L"AllUsersProfile", lpDir, eAddName, eAddNoDL); // same as real Env var
        }

        // C:\Documents and Settings\owner
        HANDLE hProcessHandle = GetCurrentProcess();
        HANDLE hUserToken;
        if (OpenProcessToken(hProcessHandle, TOKEN_QUERY, &hUserToken))
        {
            dwSize = MAX_PATH;
            bResult = GetUserProfileDirectoryW(hUserToken, lpDir, &dwSize);
            if (bResult)
            {
                Add_Variants( L"UserProfile", lpDir, eAddName, eAddNoDL);
            }
        }


        // Add the new CLSIDL variables (some have duplicate values to above)
        AddAll_CSIDL();
    }
}


WCHAR * EnvironmentValues::ExpandEnvironmentValueW(const WCHAR * lpOld)
{
    Initialize();

    // Replace all the "environment" values into their real values
    const VectorT<StringPairW> & stringPairVector = *this;

    WCHAR * lpMassagedOld = ReplaceAllStringsAllocW(lpOld, stringPairVector);

    return lpMassagedOld;
}


char * EnvironmentValues::ExpandEnvironmentValueA(const char * lpOld)
{
    Initialize();

    char * lpMassagedOld = NULL;

    WCHAR * lpOldWide = ToUnicode(lpOld);
    if (lpOldWide)
    {
        const VectorT<StringPairW> & stringPairVector = *this;

        WCHAR * lpMassagedOldWide = ReplaceAllStringsAllocW(lpOldWide, stringPairVector);
        if (lpMassagedOldWide)
        {
            lpMassagedOld = ToAnsi(lpMassagedOldWide);
            free(lpMassagedOldWide);
        }

        free(lpOldWide);
    }

    return lpMassagedOld;
}


void EnvironmentValues::AddEnvironmentValue(const WCHAR * lpOld, const WCHAR * lpNew)
{
    Initialize();

    StringPairW appendThis(lpOld, lpNew);
    if (AppendConstruct(appendThis))
    {
        DPF("EnvironmentValues",
            eDbgLevelInfo,
            "AddEnvironmentValue: (%S) to (%S)\n",
            appendThis.lpOld.Get(),
            appendThis.lpNew.Get() );
    }
}



//-------------------------------------------------------------------------------------------------------------
CorrectPathChangesBase::CorrectPathChangesBase()
{
    lpEnvironmentValues         = NULL;
    bInitialized                = FALSE;
    bEnabled                    = TRUE;
}

CorrectPathChangesBase::~CorrectPathChangesBase()
{
    if (lpEnvironmentValues)
        delete lpEnvironmentValues;

    // Call the destructor on each item in the vector list.
    for (int i = 0; i < vKnownPathFixes.Size(); ++i)
    {
        StringPairW & stringPair = vKnownPathFixes[i];

        // Call the destuctor explicitly
        stringPair.~StringPairW();
    }
}

BOOL CorrectPathChangesBase::ClassInit()
{
    lpEnvironmentValues = new EnvironmentValues;
    return lpEnvironmentValues != NULL;
}


/*++

  Func:   AddEnvironmentValue

  Params: dwIndex
          lpOld        Name of "environment" variable
          lpNew        Value of "environment" variable

--*/
void CorrectPathChangesBase::AddEnvironmentValue(const WCHAR * lpOld, const WCHAR * lpNew )
{
    if (lpEnvironmentValues)
    {
        lpEnvironmentValues->AddEnvironmentValue(lpOld, lpNew);
    }
}

/*++

  Func:   InsertPathChangeW

  Params:
          lpOld     Old Win9x path
          lpNew     New Win2000 path

  Desc:   Insert the Old/New string pair into lpKnownPathFixes
          making sure the list is large enough.
--*/
void CorrectPathChangesBase::InsertPathChangeW( const WCHAR * lpOld, const WCHAR * lpNew )
{
    // Ignore identical strings
    if (lstrcmpiW(lpOld, lpNew) == 0)
        return;

    // Ignore duplicates
    int i;
    for (i = 0; i < vKnownPathFixes.Size(); ++i)
    {
        StringPairW & stringPair = vKnownPathFixes[i];

        if (stringPair.lpOld.CompareNoCase(lpOld) == 0)
        {
            DPF("CorrectPathChangesBase", eDbgLevelSpew, "Duplicate PathChange (%S) to (%S)\n", lpOld, lpNew );
            return;
        }
    }

    CSTRING_TRY
    {
        StringPairW appendThis(lpOld, lpNew);
        if (vKnownPathFixes.AppendConstruct(appendThis))
        {
            DPF("CorrectPathChangesBase", eDbgLevelInfo, "PathChange (%S) to (%S)\n", lpOld, lpNew);
        }
    }
    CSTRING_CATCH
    {
        // Do nothing.
    }
}


/*++

  Func:   AddPathChangeW

  Params:
          lpOld     Old Win9x path
          lpNew     New Win2000 path

  Desc:   Add lpOld/lpNew combo to the list, two times:
          first:    lpOld/short(lpNew)
          second:   short(lpOld)/short(lpNew)

--*/

void CorrectPathChangesBase::AddPathChangeW( const WCHAR * lpOld, const WCHAR * lpNew )
{
    InitializeCorrectPathChanges();

    // Replace all the "environment" values into their real values
    WCHAR * lpExpandedOld = ExpandEnvironmentValueW(lpOld);
    WCHAR * lpExpandedNew = ExpandEnvironmentValueW(lpNew);

    const WCHAR * lpNewShort = lpExpandedNew;

    // Convert lpNew to its short name
    WCHAR   lpNewShortBuffer[MAX_PATH];
    DWORD status = GetShortPathNameW(lpExpandedNew, lpNewShortBuffer, MAX_PATH);
    if (status > 0 && status < MAX_PATH)
    {
        lpNewShort = lpNewShortBuffer;
    }

    // first: lpOld/short(lpNew)
    InsertPathChangeW(lpExpandedOld, lpNewShort);

    // Convert lpOld to its short name
    WCHAR lpOldShort[MAX_PATH];
    status = GetShortPathNameW(lpExpandedOld, lpOldShort, MAX_PATH);
    if (status > 0 && status < MAX_PATH) // successfully got the short path
    {
        if (_wcsicmp(lpOld, lpOldShort) != 0)
        {
            // second:   short(lpOld)/short(lpNew)
            InsertPathChangeW( lpOldShort, lpNewShort );
        }
    }

    free(lpExpandedOld);
    free(lpExpandedNew);
}

/*++

  Func:   ExpandEnvironmentValueA

  Params:  lpOld     string with environment vars

  Desc:    Return a pointer to a malloc() string with all internal env values expanded.

--*/

char * CorrectPathChangesBase::ExpandEnvironmentValueA(const char * lpOld)
{
    WCHAR * lpOldWide = ToUnicode(lpOld);

    // Replace all the "environment" values into their real values
    WCHAR * lpExpandedOldWide = ExpandEnvironmentValueW(lpOldWide);

    char * lpExpandedOld = ToAnsi(lpExpandedOldWide);

    free(lpOldWide);
    free(lpExpandedOldWide);

    return lpExpandedOld;
}

/*++

  Func:   ExpandEnvironmentValueW

  Params:  lpOld     string with environment vars

  Desc:    Return a pointer to a malloc() string with all internal env values expanded.

--*/

WCHAR * CorrectPathChangesBase::ExpandEnvironmentValueW(const WCHAR * lpOld)
{
    WCHAR * lpMassagedOld = NULL;

    InitializeCorrectPathChanges();

    if (lpEnvironmentValues)
    {
        lpMassagedOld = lpEnvironmentValues->ExpandEnvironmentValueW(lpOld);
    }

    return lpMassagedOld;
}

/*++

  Func:   InitializeEnvironmentValuesW

  Params: None, applies changes to lpEnvironmentValues

  Desc:   This function initializes the Environment strings
--*/
void CorrectPathChangesBase::InitializeEnvironmentValuesW( )
{
    if (lpEnvironmentValues)
    {
        lpEnvironmentValues->Initialize();
    }
}


/*++

  Func:   InitializePathFixes

  Params: None, applies changes to lpEnvironmentValues

  Desc:   This function initializes the built-in path changes
--*/
void CorrectPathChangesBase::InitializePathFixes( )
{
}

/*++

  Func:   InitializeCorrectPathChanges

  Params: None.

  Desc:   Initialize the CorrectPathChangesBase values, both A and W versions.
          This *must* be called prior to calling either CorrectPathChangesA or CorrectPathChangesW
--*/
void CorrectPathChangesBase::InitializeCorrectPathChanges( )
{
    if (!bInitialized)
    {
        BOOL isEnabled = bEnabled; // remember previous enabled state

        // We must not be enabled while we are initializing, otherwise
        // we can (and do!) hook routines that we are trying to use while
        // grabbing values from the system.
        bEnabled = FALSE;
        bInitialized = TRUE;

        InitializeEnvironmentValuesW();
        InitializePathFixes();

        bEnabled = isEnabled;
    }
}


/*++

   Helper routine to call CorrectPathA, allocates necessary buffer space and returns a pointer
   to the corrected path.  Caller is responsible for releasing the memory by calling free().

--*/

char *  CorrectPathChangesBase::CorrectPathAllocA(const char * str)
{
    if (str == NULL)
        return NULL;

    // Convert lpOrig to WCHAR, correct the WCHAR path, then convert back to char

    WCHAR * strWide = ToUnicode(str);

    // Correct
    WCHAR * strCorrectedWide = CorrectPathAllocW(strWide);

    char * strCorrected = ToAnsi(strCorrectedWide);

    free(strWide);
    free(strCorrectedWide);

    return strCorrected;
}

/*++

   Helper routine to call CorrectPathW, allocates necessary buffer space and returns a pointer
   to the corrected path.  Caller is responsible for releasing the memory by calling free().

--*/

WCHAR * CorrectPathChangesBase::CorrectPathAllocW(const WCHAR * str)
{
    if (str == NULL)
        return NULL;

    // Make sure the paths have been initialized.
    InitializeCorrectPathChanges();

    if (bEnabled)
    {
        WCHAR * strCorrected = ReplaceAllStringsAllocW(str, vKnownPathFixes);

        return strCorrected;
    }
    else
    {
        return StringDuplicateW(str);
    }
}

void CorrectPathChangesBase::AddFromToPairW(const WCHAR * lpFromToPair )
{
    // Make sure the paths have been initialized.
    InitializeCorrectPathChanges();

    WCHAR * FromPath = NULL;
    WCHAR * ToPath = NULL;
    const WCHAR * PathBegin = NULL;
    char argSeperator = 0; // Stop parsing the string when we reach this char

    SkipBlanksW(lpFromToPair);

    // Malformed input, stop processing
    if (*lpFromToPair == 0)
        goto AllDone;

    // If the beginning of the string is a quote, look for the matching close quote
    if (*lpFromToPair == '"')
    {
        argSeperator = L'"';
        lpFromToPair += 1;
    }

    // The beginning of the From path
    PathBegin = lpFromToPair;

    // Search for the first from/to seperator, this is end of the From path
    while (*lpFromToPair != L';')
    {
        // Malformed input, stop processing
        if (*lpFromToPair == 0)
            goto AllDone;

        lpFromToPair += 1;
    }

    // Malformed input, stop processing
    if (lpFromToPair == PathBegin)
        goto AllDone;

    // Copy into our From string
    FromPath = StringNDuplicateW(PathBegin, (int)(lpFromToPair - PathBegin));

    lpFromToPair += 1; // Skip the from/to seperator

    // The beginning of the To path
    PathBegin = lpFromToPair;

    // Search for argSeperator, this is end of the To path
    while (*lpFromToPair != argSeperator)
    {
        // Found the end of the string, To path is definately complete
        if (*lpFromToPair == 0)
            break;

        lpFromToPair += 1;
    }

    // Malformed input, stop processing
    if (lpFromToPair == PathBegin)
        goto AllDone;

    // Copy into our To string
    ToPath = StringNDuplicateW(PathBegin, (int)(lpFromToPair - PathBegin));

    // Success!
    AddPathChangeW(FromPath, ToPath);

    AllDone:
    free(FromPath);
    free(ToPath);
}

/*++

    Take a single string containing (multiple) path change pairs,
    split them up and call AddPathChangeW.
    The from/to pair is seperated by a : (colon)
    If a path contains spaces, the entire pair must be surrounded by quotes

    Example:
    "%windir%\Goofy Location:%SystemDir%\CorrectLocation" %windir%\Goofy2:%SystemDir%\CorrectLocation2

    will call
    AddPathChangeW("%windir%\Goofy Location", "%SystemDir%\CorrectLocation");
    AddPathChangeW("%windir%\Goofy2", "%SystemDir%\CorrectLocation2");

--*/
void CorrectPathChangesBase::AddCommandLineW(const WCHAR * lpCommandLine )
{
    if (!lpCommandLine || *lpCommandLine == 0)
        return;

    DPF("CorrectPathChangesBase", eDbgLevelInfo, "AddCommandLine(%S)\n", lpCommandLine);

    int argc;
    LPWSTR * argv = _CommandLineToArgvW(lpCommandLine, &argc);
    if (!argv)
        return;

    for (int i = 0; i < argc; ++i)
    {
        AddFromToPairW(argv[i]);
    }

    free(argv);
}

/*++

    Simply widen the string and call AddCommandLineW

--*/
void CorrectPathChangesBase::AddCommandLineA(const char * lpCommandLine )
{
    if (!lpCommandLine || *lpCommandLine == 0)
        return;

    WCHAR * wszCommandLine = ToUnicode(lpCommandLine);

    AddCommandLineW(wszCommandLine);

    free(wszCommandLine);
}

// Get the full path to wordpad.exe from the registry
BOOL GetWordpadPath(CString & csWordpad)
{
    CSTRING_TRY
    {
        csWordpad.Truncate(0);

        LONG lStatus = RegQueryValueExW(csWordpad,
                                        HKEY_CLASSES_ROOT,
                                        L"Applications\\wordpad.exe\\shell\\open\\command",
                                        NULL);
        if (ERROR_SUCCESS == lStatus)
        {
            // String is of the form "wordpad path" "%1"
            // We want to grab all the stuff between the first pair of quotes
            if (csWordpad[0] == L'"')
            {
                int nNextQuote = csWordpad.Find(L'"', 1);
                if (nNextQuote > 0)
                {
                    csWordpad.Truncate(nNextQuote);
                    csWordpad.Delete(0, 1);

                    return TRUE;
                }
            }
        }
    }
    CSTRING_CATCH
    {
        // Fall thru
    }

    return FALSE;
}

void CorrectPathChangesUser::InitializePathFixes()
{
    // The order of this list is important.  Early entries may create paths that are modified by later entries.

    // Hardcoded bad path
    AddPathChangeW( L"c:\\windows",                                   L"%WinDir%" );
    // robkenny 4/2/2001 Do not redirect Program Files, because it is common to
    // create this directory on many hard drives, especially when c:\ is nearly full
//    AddPathChangeW( L"c:\\program files",                             L"%ProgramFiles%" );

    // Moved system applications
    AddPathChangeW( L"%WinDir%\\rundll32.exe",                        L"%SystemDir%\\rundll32.exe" );
    AddPathChangeW( L"%WinDir%\\rundll.exe",                          L"%SystemDir%\\rundll32.exe" );
    AddPathChangeW( L"%WinDir%\\write.exe",                           L"%SystemDir%\\write.exe" );
    AddPathChangeW( L"%WinDir%\\dxdiag.exe",                          L"%SystemDir%\\dxdiag.exe" );

    CSTRING_TRY
    {
        CString csWordpad;
        if (GetWordpadPath(csWordpad))
        {
            AddPathChangeW( L"%WinDir%\\wordpad.exe",                         csWordpad);
            AddPathChangeW( L"%ProgramFiles%\\Accessories\\wordpad.exe",      csWordpad);
        }
    }
    CSTRING_CATCH
    {
        // Do nothing
    }


    // Win9x single user locations (also default)
    AddPathChangeW( L"%WinDir%\\Start Menu",                          L"%UserStartMenu%" );
    AddPathChangeW( L"%WinDir%\\Desktop",                             L"%UserDesktop%" );
    AddPathChangeW( L"%WinDir%\\Favorites",                           L"%UserFavorites%" );
    // These locations are properly internationalized.  Duplicates of above for English
    AddPathChangeW( L"%WinDir%\\%CSIDL_STARTMENU_NAME%",              L"%UserStartMenu%" );
    AddPathChangeW( L"%WinDir%\\%CSIDL_DESKTOPDIRECTORY_NAME%",       L"%UserDesktop%" );
    AddPathChangeW( L"%WinDir%\\%CSIDL_FAVORITES_NAME%",              L"%UserFavorites%" );


    // Win9x & WinNT multi user locations
    AddPathChangeW( L"%WinDir%\\Profiles\\%Username%\\Start Menu",                                  L"%UserStartMenu%" );
    AddPathChangeW( L"%WinDir%\\Profiles\\%Username%\\Desktop",                                     L"%UserDesktop%" );
    AddPathChangeW( L"%WinDir%\\Profiles\\%Username%\\Favorites",                                   L"%UserFavorites%" );
    // These locations are properly internationalized.  Duplicates of above for English
    AddPathChangeW( L"%WinDir%\\Profiles\\%Username%\\%CSIDL_STARTMENU_NAME%",                      L"%UserStartMenu%" );
    AddPathChangeW( L"%WinDir%\\Profiles\\%Username%\\%CSIDL_DESKTOPDIRECTORY_NAME%",               L"%UserDesktop%" );
    AddPathChangeW( L"%WinDir%\\Profiles\\%Username%\\%CSIDL_FAVORITES_NAME%",                      L"%UserFavorites%" );


    // WinNT all user location
    AddPathChangeW( L"%WinDir%\\Profiles\\All Users\\Start Menu",                                   L"%AllStartMenu%" );
    AddPathChangeW( L"%WinDir%\\Profiles\\All Users\\Desktop",                                      L"%AllDesktop%" );
    AddPathChangeW( L"%WinDir%\\Profiles\\All Users\\Favorites",                                    L"%UserFavorites%" ); // Should be %AllFavorites%, but IE 5.0 doesn't look there.
    // These locations are properly internationalized.  Duplicates of above for English
    AddPathChangeW( L"%WinDir%\\Profiles\\%AllUsersProfile_NAME%\\%CSIDL_STARTMENU_NAME%",          L"%AllStartMenu%" );
    AddPathChangeW( L"%WinDir%\\Profiles\\%AllUsersProfile_NAME%\\%CSIDL_DESKTOPDIRECTORY_NAME%",   L"%AllDesktop%" );
    AddPathChangeW( L"%WinDir%\\Profiles\\%AllUsersProfile_NAME%\\%CSIDL_FAVORITES_NAME%",          L"%UserFavorites%" ); // Should be %AllFavorites%, but IE 5.0 doesn't look there.


    // Win9x deleted DirectX files
    AddPathChangeW( L"ddhelp.exe",                                    L"ddraw.dll" );
    AddPathChangeW( L"ddraw16.dll",                                   L"ddraw.dll" );
    AddPathChangeW( L"dsound.vxd",                                    L"ddraw.dll" );
}

// Does the current process have permission to write into this directory?
BOOL CanWriteHere(DWORD clsid)
{
    WCHAR   wszDir[MAX_PATH];
    HRESULT result = SHGetFolderPathW( NULL, clsid, NULL, SHGFP_TYPE_DEFAULT, wszDir );
    if (SUCCEEDED(result))
    {
        //WCHAR wszTempFile[MAX_PATH];

        // We do not use GetTempFileName() to test if we have permission
        // to the directory even though it does all that we need.  Unfortunately
        // the temp file will appear in the start menu since it is not hidden.
        // Emulate the behaviour of GetTempFileName but use our file attributes.


        // Loop a bunch of times attempting to create a temp file,
        // If we can create this file return immediately,
        // If we have insuffient permission return immediately
        // certain other errors will return immediately
        // otherwise we'll attempt to open the next temp file name

        // 100 is totally arbitrary: just need to attempt this a bunch of times
        static const int MaxTempFileAttempts = 100;

        int i;
        for (i = 0; i < MaxTempFileAttempts; ++i)
        {
            HANDLE hTempFile = INVALID_HANDLE_VALUE;

            CSTRING_TRY
            {
                CString csTempFile;
                csTempFile.Format(L"%s\\CFP%08x.tmp", wszDir, i);

                DPF("CanWriteHere", eDbgLevelSpew, "File(%S)\n", csTempFile.Get());

                hTempFile = CreateFileW(
                    csTempFile,
                    GENERIC_WRITE | DELETE,
                    0, // no sharing
                    NULL,
                    CREATE_NEW,
                    FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
                    NULL
                    );
            }
            CSTRING_CATCH
            {
                // do nothing
            }

            if (hTempFile != INVALID_HANDLE_VALUE)
            {
                DPF("CanWriteHere", eDbgLevelSpew, "success\n");

                CloseHandle(hTempFile);
                return TRUE;
            }
            else
            {
                // Borrowed this code from GetTempFileName:
                DWORD LastError = GetLastError();
                DPF("CanWriteHere", eDbgLevelSpew, "Error(0x%08x)\n", LastError);

                switch (LastError)
                {
                    case ERROR_INVALID_PARAMETER     :
                    case ERROR_WRITE_PROTECT         :
                    case ERROR_FILE_NOT_FOUND        :
                    case ERROR_BAD_PATHNAME          :
                    case ERROR_INVALID_NAME          :
                    case ERROR_PATH_NOT_FOUND        :
                    case ERROR_NETWORK_ACCESS_DENIED :
                    case ERROR_DISK_CORRUPT          :
                    case ERROR_FILE_CORRUPT          :
                    case ERROR_DISK_FULL             :
                        // An error from which we cannot recover...
                        return FALSE;

                    case ERROR_ACCESS_DENIED         :
                        // It's possible for us to hit this if there's a
                        // directory with the name we're trying; in that
                        // case, we can usefully continue.
                        // CreateFile() uses BaseSetLastNTError() to set
                        // LastStatusValue to the actual NT error in the
                        // TEB; we just need to check it, and only abort
                        // if it's not a directory.
                        // This was bug #397477.
                        if (NtCurrentTeb()->LastStatusValue != STATUS_FILE_IS_A_DIRECTORY)
                        {
                            // Insuffient permission
                            return FALSE;
                        }
                }
            }
        }

    }

    return FALSE;
}

void CorrectPathChangesAllUser::InitializePathFixes()
{
    CorrectPathChangesUser::InitializePathFixes();

    // The choice to put these values into All Users instead of <UserName>
    // was not taken lightly.  The problem is: some apps create  ...\All Users\Start Menu\folder
    // then attempt to place files into c:\windows\Start Menu\folder or username\Start Menu\folder.
    // Yes the apps are WRONG, but we want them to work.  By directing all of these paths
    // to All Users we *know* where the files will be placed and can make sure they all are the same place.

    // Another note, IE 5.0 does *not* look in All Users\Favorites for links,
    // so we force all favorites to end up in the user favorites.  Sheesh.

    // We add these changes twice, the first to convert any long path names to the All User dir,
    // the second to convert any short path names to All User.

    if (CanWriteHere(CSIDL_COMMON_STARTMENU))
    {
        AddPathChangeW( L"%UserStartMenu%",                               L"%AllStartMenu%" );
    }
    else
    {
        DPF("CorrectPathChangesAllUser", eDbgLevelInfo, "*NOT* forcing %UserStartMenu% to %AllStartMenu% -- insufficient permission");
    }

    /*
    // 05/11/2001 robkenny:
    // We are nolonger modifying the Desktop directory
    if (CanWriteHere(CSIDL_COMMON_DESKTOPDIRECTORY))
    {
        AddPathChangeW( L"%UserDesktop%",                                 L"%AllDesktop%" );
    }
    else
    {
        DPF("CorrectPathChangesAllUser", eDbgLevelInfo, "*NOT* forcing %UserDesktop% to %AllDesktop% -- insufficient permission");
    }
    */


    /*
    // IE 5.0/5.5 doesn't use All Users 
    if (CanWriteHere(CSIDL_COMMON_FAVORITES))
    {
        AddPathChangeW( L"%UserFavorites%",                              L"%AllFavorites%" ); // IE 5.0 doesn't use All Users
    }
    else
    {
        DPF("CorrectPathChangesAllUser", eDbgLevelInfo, "*NOT* forcing %UserFavorites% to %AllFavorites% -- insufficient permission");
    }
    */
}

};  // end of namespace ShimLib