able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/appcompat/shims/lib/classcfp.cpp

1282 lines
39 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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 "Userenv.h"
#include <stdio.h>
namespace ShimLib
{
/*++
A simple string class.
Mostly to ease the pain and drudgery of string manipulation in StringISub
--*/
class SimpleString
{
protected:
DWORD dwLen; // String Length
DWORD dwSize; // String Data size
WCHAR * lpData; // String Data
bool Resize(DWORD dwSize); // Make buffer large enough for dwSize characters (not bytes)
public:
SimpleString();
~SimpleString();
//
// Note, this ctor should only be used for const.
//
SimpleString(LPCWSTR pwsz, DWORD dwLen)
{
lpData = (LPWSTR)pwsz;
this->dwLen = dwLen;
dwSize = 0;
}
DWORD Length() const; // Number of characters in string
bool Append(const SimpleString & string);
BOOL Set(const WCHAR * string);
BOOL SetN(const WCHAR * string, DWORD dwStringLen);
const WCHAR * Get() const;
BOOL StringISub(const SimpleString & ssMatch, const SimpleString & ssReplace);
WCHAR * ReleaseString(); // Caller now owns the string
operator const WCHAR * () const;
SimpleString & operator = (const SimpleString & string);
static WCHAR * ReplaceAllStringsAllocW(const WCHAR * lpOrig, const StringPairW * ReplaceList, DWORD dwReplaceListSize);
};
typedef const SimpleString ConstSimpleString;
/*++
Constructor, init all values
--*/
SimpleString::SimpleString()
{
dwLen = 0;
dwSize = 0;
lpData = NULL;
}
/*++
Destructor, free memory
--*/
SimpleString::~SimpleString()
{
if (lpData && dwSize)
free(lpData);
}
/*++
Return the number of char in the string
--*/
DWORD SimpleString::Length() const
{
return dwLen;
}
/*++
Make the string large enough to hold size characters.
Note: size should include EOS at the end.
--*/
bool SimpleString::Resize(DWORD size)
{
if (size > dwSize)
{
lpData = (WCHAR *) realloc(lpData, size * sizeof(WCHAR));
dwSize = size;
}
return(size == 0) || (lpData != NULL);
}
/*++
Append string onto the end of this.
--*/
bool SimpleString::Append(const SimpleString & string)
{
bool stringSafe = Resize(Length() + string.Length() + 1);
if (stringSafe)
{
wcscat(lpData, string);
dwLen = Length() + string.Length();
}
return stringSafe;
}
/*++
Initialize this with a char string
--*/
BOOL SimpleString::Set(const WCHAR * string)
{
return SetN(string, wcslen(string));
}
/*++
Return a pointer to the string, class still owns pointer.
--*/
const WCHAR * SimpleString::Get() const
{
return lpData;
}
/*++
Initialize this with the first stringLen chars in string.
--*/
BOOL SimpleString::SetN(const WCHAR * string, DWORD stringLen)
{
BOOL bAllocGood = Resize(stringLen + 1);
if (bAllocGood)
{
dwLen = stringLen;
wcsncpy(lpData, string, stringLen);
lpData[stringLen] = 0;
}
return bAllocGood;
}
/*++
Release ownership of the string.
Caller is now responsible for calling free()
--*/
WCHAR * SimpleString::ReleaseString()
{
WCHAR * lpOwner = lpData;
dwLen = 0;
dwSize = 0;
lpData = NULL;
return lpOwner;
}
/*++
String substitution, replace all ssMatch with ssReplace
--*/
BOOL SimpleString::StringISub(const SimpleString & ssMatch, const SimpleString & ssReplace)
{
// Look to see if the match string exists
WCHAR * lpMatchInString = wcsistr( lpData, ssMatch );
if (lpMatchInString != NULL)
{
// The remainder of the uncorrected string
SimpleString strRemainder;
if (!strRemainder.Set(lpMatchInString + ssMatch.Length()))
return FALSE;
BOOL stringRemainderReplaced = strRemainder.StringISub(ssMatch, ssReplace);
if (!SetN(lpData, (DWORD)(lpMatchInString - lpData)))
return FALSE;
if (!Append(ssReplace))
return FALSE;
if (!Append(strRemainder))
return FALSE;
return stringRemainderReplaced;
}
else
{
return FALSE;
}
}
/*++
Return a const pointer to the string.
--*/
SimpleString::operator const WCHAR * () const
{
return lpData;
}
/*++
Assignment operator, safely make a duplicate.
--*/
SimpleString & SimpleString::operator = (const SimpleString & string)
{
SetN(string.lpData, string.dwLen);
return *this;
}
/*++
Func: ReplaceAllStringsAllocW
Params: lpOrig Original string
ReplaceList Array of string old/new pairs
dwReplaceListSize Number of entries in ReplaceList
Return: WCHAR * Newly allocated string containing (possibly) modified string
Desc: For each entry in ReplaceList replace the string in lpOrig, placing the result into lpCorrected.
--*/
WCHAR * SimpleString::ReplaceAllStringsAllocW(
const WCHAR * lpOrig,
const StringPairW * ReplaceList,
DWORD dwReplaceListSize)
{
//DPF("SimpleString", eDbgLevelInfo, "\nReplaceAllStringsAllocW(%S)\n", lpOrig);
SimpleString ssReplaced;
if (ssReplaced.Set(lpOrig))
{
for (DWORD i = 0; i < dwReplaceListSize; ++i)
{
// Attempt a string substitution
ssReplaced.StringISub(
ConstSimpleString(ReplaceList[i].lpOld, ReplaceList[i].dwLenOld),
ConstSimpleString(ReplaceList[i].lpNew, ReplaceList[i].dwLenNew));
//DPF("SimpleString", eDbgLevelInfo, "Old(%S)\n", ReplaceList[i].lpOld);
//DPF("SimpleString", eDbgLevelInfo, "New(%S)\n", ReplaceList[i].lpNew);
//DPF("SimpleString", eDbgLevelInfo, "Val(%S)\n", ssReplaced.Get());
}
}
return ssReplaced.ReleaseString();
}
//-------------------------------------------------------------------------------------------------------------
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(lpEnvName);
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)
{
AddEnvironmentValue( L"%WinDir%", lpDir );
AddEnvironmentValue( L"%SystemRoot%", lpDir );
lpDir[2] = 0;
AddEnvironmentValue( L"%SystemDrive%", lpDir );
}
dwChars = GetSystemDirectoryW( lpDir, MAX_PATH);
if (dwChars != 0)
{
AddEnvironmentValue( L"%SystemDir%", lpDir );
}
dwSize = MAX_PATH;
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 = MAX_PATH;
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
WCHAR * lpMassagedOld = SimpleString::ReplaceAllStringsAllocW(lpOld, vectorList, nVectorListMax );
return lpMassagedOld;
}
char * EnvironmentValues::ExpandEnvironmentValueA(const char * lpOld)
{
Initialize();
char * lpMassagedOld = NULL;
WCHAR * lpOldWide = ToUnicode(lpOld);
if (lpOldWide)
{
WCHAR * lpMassagedOldWide = SimpleString::ReplaceAllStringsAllocW(lpOldWide, vectorList, nVectorListMax );
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 (Append(appendThis))
{
DPF("EnvironmentValues", eDbgLevelInfo, "AddEnvironmentValue: (%S) to (%S)\n", appendThis.lpOld, appendThis.lpNew );
}
}
//-------------------------------------------------------------------------------------------------------------
CorrectPathChangesBase::CorrectPathChangesBase()
{
lpEnvironmentValues = new EnvironmentValues;
dwKnownPathFixesCount = 0;
lpKnownPathFixes = (StringPairW *)malloc(sizeof(StringPairW)); // prime the pump for realloc later
bInitialized = FALSE;
bEnabled = TRUE;
InitializeCriticalSection(&csCritical);
}
CorrectPathChangesBase::~CorrectPathChangesBase()
{
if (lpEnvironmentValues)
delete lpEnvironmentValues;
if (lpKnownPathFixes)
free(lpKnownPathFixes);
DeleteCriticalSection(&csCritical);
}
void CorrectPathChangesBase::EnterCS()
{
EnterCriticalSection(&csCritical);
}
void CorrectPathChangesBase::LeaveCS()
{
LeaveCriticalSection(&csCritical);
}
/*++
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 < dwKnownPathFixesCount; ++i)
{
if (_wcsicmp(lpKnownPathFixes[i].lpOld, lpOld) == 0)
{
DPF("CorrectPathChangesBase", eDbgLevelSpew, "Duplicate PathChange (%S) to (%S)\n", lpOld, lpNew );
return;
}
}
// Grow the list
size_t oldListSize = dwKnownPathFixesCount * sizeof(StringPairW);
lpKnownPathFixes = (StringPairW *)realloc(lpKnownPathFixes, oldListSize + sizeof(StringPairW));
if (lpKnownPathFixes == NULL)
{
// Alloc failed, don't add anymore
return;
}
DWORD dwLenOld = wcslen(lpOld);
wcsncpy( lpKnownPathFixes[dwKnownPathFixesCount].lpOld, lpOld, dwLenOld + 1);
lpKnownPathFixes[dwKnownPathFixesCount].dwLenOld = dwLenOld;
DWORD dwLenNew = wcslen(lpNew);
wcsncpy( lpKnownPathFixes[dwKnownPathFixesCount].lpNew, lpNew, dwLenNew + 1);
lpKnownPathFixes[dwKnownPathFixesCount].dwLenNew = dwLenNew;
DPF("CorrectPathChangesBase", eDbgLevelInfo, "PathChange (%S) to (%S)\n", lpKnownPathFixes[dwKnownPathFixesCount].lpOld, lpKnownPathFixes[dwKnownPathFixesCount].lpNew );
dwKnownPathFixesCount += 1;
}
/*++
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 sets the "environment" values to their explicit values
--*/
void CorrectPathChangesBase::InitializeEnvironmentValuesW( )
{
if (lpEnvironmentValues)
{
lpEnvironmentValues->Initialize();
}
}
/*++
Func: InitializePathFixes
Params: None, applies changes to lpEnvironmentValues
Desc: This function sets the "environment" values to their explicit values
--*/
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( )
{
// This seems a little odd, but we wanted to minimize the amount of time spent
// attempting to enter the critical section. The simple code is:
// EnterCS();
// if (!bInitialized)
// {
// BOOL isEnabled = bEnabled; // remember previous enabled state
//
// This would enter the critical section every time we make sure
// the class is initialized.
if (!bInitialized)
{
EnterCS();
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;
}
LeaveCS();
}
}
/*++
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 = SimpleString::ReplaceAllStringsAllocW(str, lpKnownPathFixes, dwKnownPathFixesCount);
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));
lpFromToPair += 1; // Skip the argSeperator
// 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)
{
csWordpad.Truncate(0);
DWORD dwRegType;
LONG lStatus = RegQueryValueExW(csWordpad,
HKEY_CLASSES_ROOT,
L"Applications\\wordpad.exe\\shell\\open\\command",
NULL, // default key
&dwRegType);
if (ERROR_SUCCESS == lStatus &&
(dwRegType == REG_SZ || dwRegType == REG_EXPAND_SZ))
{
// 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);
if (dwRegType == REG_EXPAND_SZ)
{
csWordpad.ExpandEnvironmentStringsW();
}
return TRUE;
}
}
}
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)
{
BOOL bCanWriteHere = FALSE;
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)
{
swprintf(wszTempFile, L"%s\\CFP%08x.tmp", wszDir, i);
DPF("CanWriteHere", eDbgLevelSpew, "File(%S)\n", wszTempFile);
HANDLE hTempFile = CreateFileW(
wszTempFile,
GENERIC_WRITE | DELETE,
0, // no sharing
NULL,
CREATE_NEW,
FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
NULL
);
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 bCanWriteHere;
}
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
Reference in a new issue Copy permalink