Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
50969b0ea2
Windows2003-3790/windows/appcompat/shims/layer/correctfilepaths.cpp

2621 lines
80 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 2000 Microsoft Corporation
Module Name:
CorrectFilePaths.cpp
Abstract:
This APIHooks CreateProcess and attempts to convert paths from Win9x locations to Win2000
locations. For example "C:\WINNT\WRITE.EXE" will be converted to C:\WINNT\SYSTEM32\WRITE.EXE"
Notes:
This APIHook emulates Windows 9x.
Created:
12/15/1999 robkenny
Modified:
03/14/2000 robkenny Now uses ClassCFP instead of global routines.
03/31/2000 robkenny ShellExecuteEx now handle lpDirectory path as well.
05/18/2000 a-sesk GetCommandLineA and GetCommandLineW convert cmd line args to short path.
06/20/2000 robkenny Added SetFileAttributes()
06/22/2000 robkenny Reordered enum list and DECLARE_APIHOOK list to match each other.
--SERIOUS CHANGE--
10/30/2000 robkenny Added path specific fixes.
Command lines now have the EXE path removed and corrected
separately from the remainder of the command line.
11/13/2000 a-alexsm Added SetArguments & SetIconLocation hooks
11/13/2000 robkenny Changed CorrectPath to always return a valid string
by returning the original string. Must call CorrectFree
to properly release the memory.
12/14/2000 prashkud Added hooks for _lopen and _lcreat
03/10/2001 robkenny Do not convert any paths until *after* all shims have been loaded.
03/15/2001 robkenny Converted to CString
--*/
#include "precomp.h"
#include "ClassCFP.h"
IMPLEMENT_SHIM_BEGIN(CorrectFilePaths)
#include "ShimHookMacro.h"
APIHOOK_ENUM_BEGIN
APIHOOK_ENUM_ENTRY(CreateProcessA)
APIHOOK_ENUM_ENTRY(CreateProcessW)
APIHOOK_ENUM_ENTRY(WinExec)
APIHOOK_ENUM_ENTRY(ShellExecuteA)
APIHOOK_ENUM_ENTRY(ShellExecuteW)
APIHOOK_ENUM_ENTRY(ShellExecuteExA)
APIHOOK_ENUM_ENTRY(ShellExecuteExW)
APIHOOK_ENUM_ENTRY(GetCommandLineA)
APIHOOK_ENUM_ENTRY(GetCommandLineW)
APIHOOK_ENUM_ENTRY(GetPrivateProfileIntA)
APIHOOK_ENUM_ENTRY(GetPrivateProfileIntW)
APIHOOK_ENUM_ENTRY(GetPrivateProfileSectionA)
APIHOOK_ENUM_ENTRY(GetPrivateProfileSectionW)
APIHOOK_ENUM_ENTRY(GetPrivateProfileSectionNamesA)
APIHOOK_ENUM_ENTRY(GetPrivateProfileSectionNamesW)
APIHOOK_ENUM_ENTRY(GetPrivateProfileStringA)
APIHOOK_ENUM_ENTRY(GetPrivateProfileStringW)
APIHOOK_ENUM_ENTRY(GetPrivateProfileStructA)
APIHOOK_ENUM_ENTRY(GetPrivateProfileStructW)
APIHOOK_ENUM_ENTRY(WritePrivateProfileSectionA)
APIHOOK_ENUM_ENTRY(WritePrivateProfileSectionW)
APIHOOK_ENUM_ENTRY(WritePrivateProfileStringA)
APIHOOK_ENUM_ENTRY(WritePrivateProfileStringW)
APIHOOK_ENUM_ENTRY(WritePrivateProfileStructA)
APIHOOK_ENUM_ENTRY(WritePrivateProfileStructW)
APIHOOK_ENUM_ENTRY(CopyFileA)
APIHOOK_ENUM_ENTRY(CopyFileW)
APIHOOK_ENUM_ENTRY(CopyFileExA)
APIHOOK_ENUM_ENTRY(CopyFileExW)
APIHOOK_ENUM_ENTRY(CreateDirectoryA)
APIHOOK_ENUM_ENTRY(CreateDirectoryW)
APIHOOK_ENUM_ENTRY(CreateDirectoryExA)
APIHOOK_ENUM_ENTRY(CreateDirectoryExW)
APIHOOK_ENUM_ENTRY(CreateFileA)
APIHOOK_ENUM_ENTRY(CreateFileW)
APIHOOK_ENUM_ENTRY(DeleteFileA)
APIHOOK_ENUM_ENTRY(DeleteFileW)
APIHOOK_ENUM_ENTRY(FindFirstFileA)
APIHOOK_ENUM_ENTRY(FindFirstFileW)
APIHOOK_ENUM_ENTRY(FindFirstFileExA)
APIHOOK_ENUM_ENTRY(FindFirstFileExW)
APIHOOK_ENUM_ENTRY(GetBinaryTypeA)
APIHOOK_ENUM_ENTRY(GetBinaryTypeW)
APIHOOK_ENUM_ENTRY(GetFileAttributesA)
APIHOOK_ENUM_ENTRY(GetFileAttributesW)
APIHOOK_ENUM_ENTRY(GetFileAttributesExA)
APIHOOK_ENUM_ENTRY(GetFileAttributesExW)
APIHOOK_ENUM_ENTRY(SetFileAttributesA)
APIHOOK_ENUM_ENTRY(SetFileAttributesW)
APIHOOK_ENUM_ENTRY(MoveFileA)
APIHOOK_ENUM_ENTRY(MoveFileW)
APIHOOK_ENUM_ENTRY(MoveFileExA)
APIHOOK_ENUM_ENTRY(MoveFileExW)
APIHOOK_ENUM_ENTRY(MoveFileWithProgressA)
APIHOOK_ENUM_ENTRY(MoveFileWithProgressW)
APIHOOK_ENUM_ENTRY(RemoveDirectoryA)
APIHOOK_ENUM_ENTRY(RemoveDirectoryW)
APIHOOK_ENUM_ENTRY(SetCurrentDirectoryA)
APIHOOK_ENUM_ENTRY(SetCurrentDirectoryW)
APIHOOK_ENUM_ENTRY(OpenFile)
APIHOOK_ENUM_ENTRY(RegSetValueA)
APIHOOK_ENUM_ENTRY(RegSetValueW)
APIHOOK_ENUM_ENTRY(RegSetValueExA)
APIHOOK_ENUM_ENTRY(RegSetValueExW)
APIHOOK_ENUM_ENTRY(_lopen)
APIHOOK_ENUM_ENTRY(_lcreat)
APIHOOK_ENUM_ENTRY_COMSERVER(SHELL32)
APIHOOK_ENUM_ENTRY(LoadImageA)
APIHOOK_ENUM_END
// This is a private define (shlapip.h) that can mess up ShellExecuteEx
#ifndef SEE_MASK_FILEANDURL
#define SEE_MASK_FILEANDURL 0x00400000
#endif
/*++
CorrectFree: free lpMalloc if it is different from lpOrig
--*/
inline void CorrectFree(char * lpMalloc, const char * lpOrig)
{
if (lpMalloc != lpOrig)
{
free(lpMalloc);
}
}
inline void CorrectFree(WCHAR * lpMalloc, const WCHAR * lpOrig)
{
if (lpMalloc != lpOrig)
{
free(lpMalloc);
}
}
/*++
Our path changing class.
Note: This is a pointer to the base class.
Note: g_PathCorrector *MUST* remain NULL until after SHIM_STATIC_DLLS_INITIALIZED
--*/
CorrectPathChangesBase * g_PathCorrector = NULL;
CorrectPathChangesBase * g_AllocatedPathCorrector = NULL;
/*++
Values that can be modified by the command line
--*/
enum PathCorrectorEnum
{
ePathCorrectorBase,
ePathCorrectorUser,
ePathCorrectorAllUser,
};
BOOL g_bCreateProcessRoutines = TRUE;
BOOL g_bGetCommandLineRoutines = FALSE;
BOOL g_bRegSetValueRoutines = FALSE;
BOOL g_bFileRoutines = TRUE;
BOOL g_bProfileRoutines = TRUE;
BOOL g_bShellLinkRoutines = TRUE;
BOOL g_bW9xPath = FALSE;
BOOL g_bLoadImage = FALSE;
PathCorrectorEnum g_pathcorrectorType = ePathCorrectorAllUser;
int g_nExtraPathCorrections = 0;
CString * g_ExtraPathCorrections;
/*++
Parse the command line.
--*/
BOOL ParseCommandLine(const char * commandLine)
{
// Force the default values
g_bCreateProcessRoutines = TRUE;
g_bGetCommandLineRoutines = FALSE;
g_bRegSetValueRoutines = FALSE;
g_bFileRoutines = TRUE;
g_bProfileRoutines = TRUE;
g_bShellLinkRoutines = TRUE;
g_bW9xPath = FALSE;
g_bLoadImage = FALSE;
g_pathcorrectorType = ePathCorrectorAllUser;
g_nExtraPathCorrections = 0;
g_ExtraPathCorrections = NULL;
// Search the beginning of the command line for these switches
//
// Switch Default Meaning
//================ ======= =========================================================
// -a Y Force shortcuts to All Users
// -c N Do not shim Create process routines
// -f N Do not shim File routines
// -p N Do not shim GetPrivateProfile routines
// -s N Do not shim IShellLink routines
// -b N Bare: Use the base corrector (has no built-in path changes)
// -u N User: Built-in paths correct to <username>/Start Menu and <username>/Desktop
// +GetCommandLine N shim GetCommandLine routines
// +RegSetValue N shim the RegSetValue and RegSetValueEx routines
// +Win9xPath N Apply Win9x *path* specific fixes (does not apply to command lines)
// -Profiles N Do not force shortcuts to All Users
// +LoadBitmap N shim the LoadBitmapA routine
//
CSTRING_TRY
{
CString csCl(commandLine);
CStringParser csParser(csCl, L" ");
int argc = csParser.GetCount();
if (csParser.GetCount() == 0)
{
return TRUE; // Not an error
}
// allocate for worst case
g_ExtraPathCorrections = new CString[argc];
if (!g_ExtraPathCorrections)
{
return FALSE; // Failure
}
g_nExtraPathCorrections = 0;
for (int i = 0; i < argc; ++i)
{
CString & csArg = csParser[i];
DPFN( eDbgLevelSpew, "Argv[%d] == (%S)\n", i, csArg.Get());
if (csArg == L"-a")
{
g_pathcorrectorType = ePathCorrectorAllUser;
}
else if (csArg == L"-b")
{
g_pathcorrectorType = ePathCorrectorBase;
}
else if (csArg == L"-u" || csArg == L"-Profiles")
{
g_pathcorrectorType = ePathCorrectorUser;
}
else if (csArg == L"-c")
{
g_bCreateProcessRoutines = FALSE;
}
else if (csArg == L"-f")
{
g_bFileRoutines = FALSE;
}
else if (csArg == L"-p")
{
g_bProfileRoutines = FALSE;
}
else if (csArg == L"-s")
{
g_bShellLinkRoutines = FALSE;
}
else if (csArg == L"+GetCommandLine")
{
DPFN( eDbgLevelInfo, "Command line routines will be shimmed\n");
g_bGetCommandLineRoutines = TRUE;
}
else if (csArg == L"+RegSetValue")
{
DPFN( eDbgLevelInfo, "RegSetValue routines will be shimmed\n");
g_bRegSetValueRoutines = TRUE;
}
else if (csArg == L"+Win9xPath")
{
DPFN( eDbgLevelInfo, "Win9x Path corrections will be applied\n");
g_bW9xPath = TRUE;
}
else if (csArg == L"+LoadImage")
{
DPFN( eDbgLevelInfo, "LoadImageA will be shimmed\n");
g_bLoadImage = TRUE;
}
else
{
g_ExtraPathCorrections[g_nExtraPathCorrections] = csArg;
g_nExtraPathCorrections += 1;
}
}
#if DBG
// Dump out the new path correction values.
{
const char *lpszPathCorrectorType = "Unknown";
if (g_pathcorrectorType == ePathCorrectorBase)
{
lpszPathCorrectorType = "ePathCorrectorBase";
}
else if (g_pathcorrectorType == ePathCorrectorUser)
{
lpszPathCorrectorType = "ePathCorrectorUser";
}
else if (g_pathcorrectorType == ePathCorrectorAllUser)
{
lpszPathCorrectorType = "ePathCorrectorAllUser";
}
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim CreateProcessRoutines = %d\n", g_bCreateProcessRoutines);
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim GetCommandLineRoutines = %d\n", g_bGetCommandLineRoutines);
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim RegSetValueRoutines = %d\n", g_bRegSetValueRoutines);
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim FileRoutines = %d\n", g_bFileRoutines);
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim ProfileRoutines = %d\n", g_bProfileRoutines);
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim ShellLinkRoutines = %d\n", g_bShellLinkRoutines);
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim LoadImageA = %d\n", g_bLoadImage);
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim W9xPath = %d\n", g_bW9xPath);
DPFN( eDbgLevelInfo, "[ParseCommandLine] Shim Path Corrector Type = %s\n", lpszPathCorrectorType);
for (int i = 0; i < g_nExtraPathCorrections; ++i)
{
DPFN( eDbgLevelInfo, "[ParseCommandLine] Extra Path Change(%S)\n", g_ExtraPathCorrections[i].Get());
}
}
#endif
}
CSTRING_CATCH
{
return FALSE;
}
return TRUE;
}
/*++
Create the appropriate g_PathCorrector
Return TRUE if we were successful in creating and initializing.
Note: We create g_AllocatedPathCorrector because g_PathCorrector must remain NULL until SHIM_STATIC_DLLS_INITIALIZED
--*/
BOOL InitPathcorrectorClass()
{
switch (g_pathcorrectorType)
{
case ePathCorrectorBase:
g_AllocatedPathCorrector = new CorrectPathChangesBase;
break;
case ePathCorrectorUser:
g_AllocatedPathCorrector = new CorrectPathChangesUser;
break;
case ePathCorrectorAllUser:
default:
g_AllocatedPathCorrector = new CorrectPathChangesAllUser;
break;
};
if (g_AllocatedPathCorrector)
{
return g_AllocatedPathCorrector->ClassInit();
}
return FALSE;
}
/*++
Add all the path corrections to the path corrector.
Call after SHIM_STATIC_DLLS_INITIALIZED
--*/
void InitializePathCorrections()
{
if (g_PathCorrector)
{
g_PathCorrector->InitializeCorrectPathChanges();
if (g_ExtraPathCorrections && g_nExtraPathCorrections)
{
// Add the command line to this Path Corrector
for (int i = 0; i < g_nExtraPathCorrections; ++i)
{
g_PathCorrector->AddFromToPairW(g_ExtraPathCorrections[i]);
}
delete [] g_ExtraPathCorrections;
g_ExtraPathCorrections = NULL;
g_nExtraPathCorrections = 0;
}
}
}
/*++
Return a pointer to the PathCorrecting object
--*/
inline CorrectPathChangesBase * GetPathcorrecter()
{
return g_PathCorrector;
}
inline void DebugSpew(const WCHAR * uncorrect, const WCHAR * correct, const char * debugMsg)
{
if (correct && uncorrect && _wcsicmp(correct, uncorrect) != 0)
{
LOGN( eDbgLevelError, "%s corrected path:\n %S\n %S\n",
debugMsg, uncorrect, correct);
}
else // Massive Spew:
{
DPFN( eDbgLevelSpew, "%s unchanged %S\n", debugMsg, uncorrect);
}
}
inline void DebugSpew(const char * uncorrect, const char * correct, const char * debugMsg)
{
if (correct && uncorrect && _stricmp(correct, uncorrect) != 0)
{
LOGN( eDbgLevelError, "%s corrected path:\n %s\n %s\n",
debugMsg, uncorrect, correct);
}
else // Massive Spew:
{
DPFN( eDbgLevelSpew, "%s unchanged %s\n", debugMsg, uncorrect);
}
}
/*++
Given a string, correct the path.
bMassagePath determines of path specific fixes are applied
(should be FALSE for command lines)
--*/
WCHAR * CorrectorCorrectPath(CorrectPathChangesBase * pathCorrector, const WCHAR * uncorrect, const char * debugMsg, BOOL bMassagePath)
{
if (uncorrect == NULL)
return NULL;
if (!pathCorrector)
return (WCHAR *)uncorrect;
const WCHAR * W9xCorrectedPath = uncorrect;
// Check and see if we need to perform the special Win9x path massaging
if (bMassagePath)
{
W9xCorrectedPath = W9xPathMassageW(uncorrect);
}
WCHAR * strCorrectFile = pathCorrector->CorrectPathAllocW(W9xCorrectedPath);
// If the allocation failed, return the original string.
// This should allow the shim routines to pass along the orignal
// values to the hooked APIs, which if they fail, will have the
// proper error codes.
if (!strCorrectFile)
{
strCorrectFile = (WCHAR *)uncorrect;
}
else if (debugMsg)
{
DebugSpew(uncorrect, strCorrectFile, debugMsg);
}
if (W9xCorrectedPath != uncorrect)
free((WCHAR *)W9xCorrectedPath);
return strCorrectFile;
}
WCHAR * CorrectPath(const WCHAR * uncorrect, const char * debugMsg, BOOL bMassagePath = g_bW9xPath)
{
WCHAR * wstrCorrectFile = const_cast<WCHAR *>(uncorrect);
CSTRING_TRY
{
CorrectPathChangesBase * pathCorrector = GetPathcorrecter();
wstrCorrectFile = CorrectorCorrectPath(pathCorrector, uncorrect, debugMsg, bMassagePath);
}
CSTRING_CATCH
{
// Fall through
}
return wstrCorrectFile;
}
/*++
Given a string, correct the path.
bMassagePath determines of path specific fixes are applied
(should be FALSE for command lines)
--*/
char * CorrectPath(const char * uncorrect, const char * debugMsg, BOOL bMassagePath = g_bW9xPath)
{
char * strCorrectFile = const_cast<char *>(uncorrect);
CSTRING_TRY
{
CString csUncorrect(uncorrect);
WCHAR * wstrCorrectFile = CorrectPath(csUncorrect, NULL, bMassagePath);
// Don't assign to strCorrectFile unless we successfully allocate the memory.
char * lpszChar = ToAnsi(wstrCorrectFile);
if (lpszChar)
{
strCorrectFile = lpszChar;
}
CorrectFree(wstrCorrectFile, csUncorrect);
}
CSTRING_CATCH
{
// Fall through
}
if (debugMsg)
{
DebugSpew(uncorrect, strCorrectFile, debugMsg);
}
return strCorrectFile;
}
DWORD APIHOOK(GetFileAttributesA)(
LPCSTR lpFileName // name of file or directory
)
{
char * strCorrect = CorrectPath(lpFileName, "GetFileAttributesA");
DWORD returnValue = ORIGINAL_API(GetFileAttributesA)(strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
DWORD APIHOOK(GetFileAttributesW)(
LPCWSTR lpFileName // name of file or directory
)
{
WCHAR * strCorrect = CorrectPath(lpFileName, "GetFileAttributesW");
DWORD returnValue = ORIGINAL_API(GetFileAttributesW)(strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
BOOL APIHOOK(SetFileAttributesA)(
LPCSTR lpFileName, // file name
DWORD dwFileAttributes // attributes
)
{
char * strCorrect = CorrectPath(lpFileName, "SetFileAttributesA");
DWORD returnValue = ORIGINAL_API(SetFileAttributesA)(strCorrect, dwFileAttributes);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
DWORD APIHOOK(SetFileAttributesW)(
LPCWSTR lpFileName, // file name
DWORD dwFileAttributes // attributes
)
{
WCHAR * strCorrect = CorrectPath(lpFileName, "SetFileAttributesW");
DWORD returnValue = ORIGINAL_API(SetFileAttributesW)(strCorrect, dwFileAttributes);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
BOOL APIHOOK(GetFileAttributesExA)(
LPCSTR lpFileName, // file or directory name
GET_FILEEX_INFO_LEVELS fInfoLevelId, // attribute
LPVOID lpFileInformation // attribute information
)
{
char * strCorrect = CorrectPath(lpFileName, "GetFileAttributesExA");
BOOL returnValue = ORIGINAL_API(GetFileAttributesExA)(strCorrect, fInfoLevelId, lpFileInformation);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
BOOL APIHOOK(GetFileAttributesExW)(
LPCWSTR lpFileName, // file or directory name
GET_FILEEX_INFO_LEVELS fInfoLevelId, // attribute
LPVOID lpFileInformation // attribute information
)
{
WCHAR * strCorrect = CorrectPath(lpFileName, "GetFileAttributesExW");
BOOL returnValue = ORIGINAL_API(GetFileAttributesExW)(strCorrect, fInfoLevelId, lpFileInformation);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for CreateProcessA
--*/
BOOL APIHOOK(CreateProcessA)(
LPCSTR lpApplicationName,
LPSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory,
LPSTARTUPINFOA lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation)
{
// Application name and command line that is passed to CreateProcess
// Will either point to lpApplicationName or strCorrectApplicationName
// Will either point to lpCommandLine or strCorrectCommandLine
const char * pstrCorrectApplicationName = lpApplicationName;
char * pstrCorrectCommandLine = lpCommandLine;
if (lpApplicationName != NULL)
{
// Get a buffer containing the application name with the corrected path
pstrCorrectApplicationName = CorrectPath(lpApplicationName, "CreateProcessA ApplicationName:");
}
if (lpCommandLine != NULL)
{
// Get a buffer containing the command line with the corrected path
pstrCorrectCommandLine = CorrectPath(lpCommandLine, "CreateProcessA CommandLine:", FALSE);
}
DPFN( eDbgLevelInfo, "CreateProcessA Application(%s) CommandLine(%s)\n", pstrCorrectApplicationName, pstrCorrectCommandLine);
BOOL returnValue = ORIGINAL_API(CreateProcessA)(pstrCorrectApplicationName,
pstrCorrectCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
lpProcessInformation);
CorrectFree(const_cast<char*>(pstrCorrectApplicationName), lpApplicationName);
CorrectFree(pstrCorrectCommandLine, lpCommandLine);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for CreateProcessW
--*/
BOOL APIHOOK(CreateProcessW)(
LPCWSTR lpApplicationName,
LPWSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCWSTR lpCurrentDirectory,
LPSTARTUPINFOW lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation)
{
// Application name and command line that is passed to CreateProcess
// Will either point to lpApplicationName or strCorrectApplicationName
// Will either point to lpCommandLine or strCorrectCommandLine
const WCHAR * pstrCorrectApplicationName = lpApplicationName;
WCHAR * pstrCorrectCommandLine = lpCommandLine;
if (lpApplicationName != NULL)
{
// Get a buffer containing the application name with the corrected path
pstrCorrectApplicationName = CorrectPath(lpApplicationName, "CreateProcessW ApplicationName:");
}
if (lpCommandLine != NULL)
{
// Get a buffer containing the command line with the corrected path
pstrCorrectCommandLine = CorrectPath(lpCommandLine, "CreateProcessW CommandLine:", FALSE);
}
DPFN( eDbgLevelInfo, "CreateProcessW Application(%S) CommandLine(%S)\n", pstrCorrectApplicationName, pstrCorrectCommandLine);
BOOL returnValue = ORIGINAL_API(CreateProcessW)(pstrCorrectApplicationName,
pstrCorrectCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
lpProcessInformation);
CorrectFree(const_cast<WCHAR *>(pstrCorrectApplicationName), lpApplicationName);
CorrectFree(pstrCorrectCommandLine, lpCommandLine);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for WinExec
--*/
UINT APIHOOK(WinExec)(LPCSTR lpCmdLine, UINT uCmdShow)
{
// Get a buffer containing the command line with the corrected path
char * strCorrect = CorrectPath(lpCmdLine, "WinExec", FALSE);
UINT returnValue = ORIGINAL_API(WinExec)(strCorrect, uCmdShow);
CorrectFree(strCorrect, lpCmdLine);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for ShellExecuteA
--*/
HINSTANCE APIHOOK(ShellExecuteA)(
HWND hwnd,
LPCSTR lpVerb,
LPCSTR lpFile,
LPCSTR lpParameters,
LPCSTR lpDirectory,
INT nShowCmd
)
{
HINSTANCE returnValue = (HINSTANCE)SE_ERR_OOM;
// Since this command is executed by the shell, it may contain %env% variables,
// expand them before calling correctpath.
CSTRING_TRY
{
CString csExpandFile(lpFile);
csExpandFile.ExpandEnvironmentStringsW();
returnValue = ORIGINAL_API(ShellExecuteA)(hwnd, lpVerb, csExpandFile.GetAnsi(), lpParameters, lpDirectory, nShowCmd);
}
CSTRING_CATCH
{
// Error expanding the string, just pass the value thru.
returnValue = ORIGINAL_API(ShellExecuteA)(hwnd, lpVerb, lpFile, lpParameters, lpDirectory, nShowCmd);
}
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for ShellExecuteW
--*/
HINSTANCE APIHOOK(ShellExecuteW)(
HWND hwnd,
LPCWSTR lpVerb,
LPCWSTR lpFile,
LPCWSTR lpParameters,
LPCWSTR lpDirectory,
INT nShowCmd
)
{
HINSTANCE returnValue = (HINSTANCE)SE_ERR_OOM;
// Since this command is executed by the shell, it may contain %env% variables,
// expand them before calling correctpath.
CSTRING_TRY
{
CString csExpandFile(lpFile);
csExpandFile.ExpandEnvironmentStringsW();
returnValue = ORIGINAL_API(ShellExecuteW)(hwnd, lpVerb, csExpandFile, lpParameters, lpDirectory, nShowCmd);
}
CSTRING_CATCH
{
// Error expanding the string, just pass the value thru.
returnValue = ORIGINAL_API(ShellExecuteW)(hwnd, lpVerb, lpFile, lpParameters, lpDirectory, nShowCmd);
}
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for ShellExecuteExA
--*/
BOOL APIHOOK(ShellExecuteExA)(
LPSHELLEXECUTEINFOA lpExecInfo
)
{
// Check for this magical internal flag that tells the system
// that lpExecInfo->lpFile is actually a file and URL combined with
// a 0 byte seperator, (file\0url\0)
// Since this is internal only, we should not be receiving bad paths.
if (lpExecInfo->fMask & SEE_MASK_FILEANDURL)
{
return ORIGINAL_API(ShellExecuteExA)(lpExecInfo);
}
const char * lpFile = lpExecInfo->lpFile;
const char * lpDirectory = lpExecInfo->lpDirectory;
char * strFileCorrect;
char * strDirCorrect;
// Check to see if app is expecting %env% substitution
if (lpExecInfo->fMask & SEE_MASK_DOENVSUBST )
{
CSTRING_TRY
{
CString csExpandedFile(lpFile);
CString csExpandedDir(lpDirectory);
csExpandedFile.ExpandEnvironmentStringsW();
csExpandedDir.ExpandEnvironmentStringsW();
strFileCorrect = CorrectPath(csExpandedFile.GetAnsi(), "ShellExecuteExA");
strDirCorrect = CorrectPath(csExpandedDir.GetAnsi(), "ShellExecuteExA");
}
CSTRING_CATCH
{
// Failed to expand the env values, pass all values untouched.
return ORIGINAL_API(ShellExecuteExA)(lpExecInfo);
}
}
else
{
strFileCorrect = CorrectPath(lpFile, "ShellExecuteExA");
strDirCorrect = CorrectPath(lpDirectory, "ShellExecuteExA");
}
// Save the original fileName
lpExecInfo->lpFile = strFileCorrect;
lpExecInfo->lpDirectory = strDirCorrect;
BOOL returnValue = ORIGINAL_API(ShellExecuteExA)(lpExecInfo);
lpExecInfo->lpFile = lpFile;
lpExecInfo->lpDirectory = lpDirectory;
CorrectFree(strFileCorrect, lpFile);
CorrectFree(strDirCorrect, lpDirectory);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for ShellExecuteExW
--*/
BOOL APIHOOK(ShellExecuteExW)(
LPSHELLEXECUTEINFOW lpExecInfo
)
{
// Check for this magical *internal* flag that tells the system
// that lpExecInfo->lpFile is actually a file and URL combined with
// a 0 byte seperator, (file\0url\0)
// Since this is internal only, we should not be receiving bad paths.
if (lpExecInfo->fMask & SEE_MASK_FILEANDURL)
{
return ORIGINAL_API(ShellExecuteExW)(lpExecInfo);
}
const WCHAR * lpFile = lpExecInfo->lpFile;
const WCHAR * lpDirectory = lpExecInfo->lpDirectory;
WCHAR * strFileCorrect;
WCHAR * strDirCorrect;
// Check to see if app is expecting %env% substitution
if (lpExecInfo->fMask & SEE_MASK_DOENVSUBST )
{
CSTRING_TRY
{
CString csExpandedFile(lpFile);
CString csExpandedDir(lpDirectory);
csExpandedFile.ExpandEnvironmentStringsW();
csExpandedDir.ExpandEnvironmentStringsW();
strFileCorrect = CorrectPath(csExpandedFile, "ShellExecuteExW");
strDirCorrect = CorrectPath(csExpandedDir, "ShellExecuteExW");
}
CSTRING_CATCH
{
// Failed to expand the env values, pass all values untouched.
return ORIGINAL_API(ShellExecuteExW)(lpExecInfo);
}
}
else
{
strFileCorrect = CorrectPath(lpFile, "ShellExecuteExW");
strDirCorrect = CorrectPath(lpDirectory, "ShellExecuteExW");
}
// Save the original fileName
lpExecInfo->lpFile = strFileCorrect;
lpExecInfo->lpDirectory = strDirCorrect;
BOOL returnValue = ORIGINAL_API(ShellExecuteExW)(lpExecInfo);
lpExecInfo->lpFile = lpFile;
lpExecInfo->lpDirectory = lpDirectory;
CorrectFree(strFileCorrect, lpFile);
CorrectFree(strDirCorrect, lpDirectory);
return returnValue;
}
/*++
Convert long command line paths to short paths for GetCommandLineW
--*/
LPCWSTR APIHOOK(GetCommandLineW)()
{
static LPCWSTR wstrCorrectCommandLine = NULL;
if (wstrCorrectCommandLine == NULL)
{
LPCWSTR wstrCommandLine = ORIGINAL_API(GetCommandLineW)();
wstrCorrectCommandLine = CorrectPath(wstrCommandLine, "GetCommandLineW", FALSE);
}
return wstrCorrectCommandLine;
}
/*++
Convert long command line paths to short paths for GetCommandLineA
--*/
LPCSTR APIHOOK(GetCommandLineA)()
{
static LPCSTR strCorrectCommandLine = NULL;
if (strCorrectCommandLine == NULL)
{
LPCSTR strCommandLine = ORIGINAL_API(GetCommandLineA)();
strCorrectCommandLine = CorrectPath(strCommandLine, "GetCommandLineA", FALSE);
}
return strCorrectCommandLine;
}
/*++
The PrivateProfile routines treat filenames differently than pathnames.
If we have Win9xPath corrections enabled, it is possible to "fix" a path
from .\example.ini to example.ini. Unfortunately the PrivateProfile routines
look for example.ini in %windir%
If we have a path that contains path seperators, we must ensure that
the resulting string also contains path separators.
--*/
char * ProfileCorrectPath(const char * uncorrect, const char * debugMsg, BOOL bMassagePath = g_bW9xPath)
{
char * strCorrect = CorrectPath(uncorrect, NULL, bMassagePath);
if (bMassagePath && uncorrect != strCorrect)
{
char * returnString = NULL;
CSTRING_TRY
{
CString csUncorrect(uncorrect);
if (csUncorrect.FindOneOf(L"\\/") >= 0)
{
// Found some path separators in the original string, check the corrected string.
// If the corrected string does not have any path separators,
// then the path was corrected from .\example.ini to example.ini
CString csCorrect(strCorrect);
if (csCorrect.FindOneOf(L"\\/") < 0)
{
// No path seperators, make this a CWD relative path
csCorrect.Insert(0, L".\\");
returnString = csCorrect.ReleaseAnsi();
}
}
}
CSTRING_CATCH
{
// Some CString error occured, make sure returnString is NULL
if (returnString != NULL)
{
free(returnString);
}
returnString = NULL;
}
if (returnString)
{
CorrectFree(strCorrect, uncorrect);
strCorrect = returnString;
}
}
if (debugMsg)
{
DebugSpew(uncorrect, strCorrect, debugMsg);
}
return strCorrect;
}
/*++
The PrivateProfile routines treat filenames differently than pathnames.
If we have Win9xPath corrections enabled, it is possible to "fix" a path
from .\example.ini to example.ini. Unfortunately the PrivateProfile routines
look for example.ini in %windir%
If we have a path that contains path seperators, we must ensure that
the resulting string also contains path separators.
--*/
WCHAR * ProfileCorrectPath(const WCHAR * uncorrect, const char * debugMsg, BOOL bMassagePath = g_bW9xPath)
{
WCHAR * strCorrect = CorrectPath(uncorrect, NULL, bMassagePath);
if (bMassagePath && uncorrect != strCorrect)
{
WCHAR * returnString = NULL;
CSTRING_TRY
{
CString csUncorrect(uncorrect);
if (csUncorrect.FindOneOf(L"\\/") >= 0)
{
// Found some path separators in the original string, check the corrected string.
// If the corrected string does not have any path separators,
// then the path was corrected from .\example.ini to example.ini
CString csCorrect(strCorrect);
if (csCorrect.FindOneOf(L"\\/") < 0)
{
// No path seperators, make this a CWD relative path
csCorrect.Insert(0, L".\\");
// Manually copy the buffer
size_t nBytes = (csCorrect.GetLength() + 1) * sizeof(WCHAR);
returnString = (WCHAR*) malloc(nBytes);
if (returnString)
{
memcpy(returnString, csCorrect.Get(), nBytes);
}
}
}
}
CSTRING_CATCH
{
// Some CString error occured, make sure returnString is NULL
if (returnString != NULL)
{
free(returnString);
}
returnString = NULL;
}
if (returnString)
{
CorrectFree(strCorrect, uncorrect);
strCorrect = returnString;
}
}
if (debugMsg)
{
DebugSpew(uncorrect, strCorrect, debugMsg);
}
return strCorrect;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileIntA
--*/
UINT APIHOOK(GetPrivateProfileIntA)(
LPCSTR lpAppName, // section name
LPCSTR lpKeyName, // key name
INT nDefault, // return value if key name not found
LPCSTR lpFileName // initialization file name
)
{
char * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileIntA");
UINT returnValue = ORIGINAL_API(GetPrivateProfileIntA)(lpAppName, lpKeyName, nDefault, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileIntW
--*/
UINT APIHOOK(GetPrivateProfileIntW)(
LPCWSTR lpAppName, // section name
LPCWSTR lpKeyName, // key name
INT nDefault, // return value if key name not found
LPCWSTR lpFileName // initialization file name
)
{
WCHAR * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileIntW");
UINT returnValue = ORIGINAL_API(GetPrivateProfileIntW)(lpAppName, lpKeyName, nDefault, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileSectionA
--*/
DWORD APIHOOK(GetPrivateProfileSectionA)(
LPCSTR lpAppName, // section name
LPSTR lpReturnedString, // return buffer
DWORD nSize, // size of return buffer
LPCSTR lpFileName // initialization file name
)
{
char * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileSectionA");
DWORD returnValue = ORIGINAL_API(GetPrivateProfileSectionA)(lpAppName, lpReturnedString, nSize, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileSectionW
--*/
DWORD APIHOOK(GetPrivateProfileSectionW)(
LPCWSTR lpAppName, // section name
LPWSTR lpReturnedString, // return buffer
DWORD nSize, // size of return buffer
LPCWSTR lpFileName // initialization file name
)
{
WCHAR * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileSectionW");
DWORD returnValue = ORIGINAL_API(GetPrivateProfileSectionW)(lpAppName, lpReturnedString, nSize, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileSectionNamesA
--*/
DWORD APIHOOK(GetPrivateProfileSectionNamesA)(
LPSTR lpszReturnBuffer, // return buffer
DWORD nSize, // size of return buffer
LPCSTR lpFileName // initialization file name
)
{
char * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileSectionNamesA");
DWORD returnValue = ORIGINAL_API(GetPrivateProfileSectionNamesA)(lpszReturnBuffer, nSize, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileSectionNamesW
--*/
DWORD APIHOOK(GetPrivateProfileSectionNamesW)(
LPWSTR lpszReturnBuffer, // return buffer
DWORD nSize, // size of return buffer
LPCWSTR lpFileName // initialization file name
)
{
WCHAR * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileSectionNamesW");
DWORD returnValue = ORIGINAL_API(GetPrivateProfileSectionNamesW)(lpszReturnBuffer, nSize, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileSectionNamesA
--*/
DWORD APIHOOK(GetPrivateProfileStringA)(
LPCSTR lpAppName, // section name
LPCSTR lpKeyName, // key name
LPCSTR lpDefault, // default string
LPSTR lpReturnedString, // destination buffer
DWORD nSize, // size of destination buffer
LPCSTR lpFileName // initialization file name
)
{
char * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileStringA");
DWORD returnValue = ORIGINAL_API(GetPrivateProfileStringA)(lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileSectionNamesA
--*/
DWORD APIHOOK(GetPrivateProfileStringW)(
LPCWSTR lpAppName, // section name
LPCWSTR lpKeyName, // key name
LPCWSTR lpDefault, // default string
LPWSTR lpReturnedString, // destination buffer
DWORD nSize, // size of destination buffer
LPCWSTR lpFileName // initialization file name
)
{
WCHAR * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileStringW");
DWORD returnValue = ORIGINAL_API(GetPrivateProfileStringW)(lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileStructA
--*/
BOOL APIHOOK(GetPrivateProfileStructA)(
LPCSTR lpszSection, // section name
LPCSTR lpszKey, // key name
LPVOID lpStruct, // return buffer
UINT uSizeStruct, // size of return buffer
LPCSTR lpFileName // initialization file name
)
{
char * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileStructA");
BOOL returnValue = ORIGINAL_API(GetPrivateProfileStructA)(lpszSection, lpszKey, lpStruct, uSizeStruct, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileStructW
--*/
BOOL APIHOOK(GetPrivateProfileStructW)(
LPCWSTR lpszSection, // section name
LPCWSTR lpszKey, // key name
LPVOID lpStruct, // return buffer
UINT uSizeStruct, // size of return buffer
LPCWSTR lpFileName // initialization file name
)
{
WCHAR * strCorrect = ProfileCorrectPath(lpFileName, "GetPrivateProfileStructW");
BOOL returnValue = ORIGINAL_API(GetPrivateProfileStructW)(lpszSection, lpszKey, lpStruct, uSizeStruct, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for GetPrivateProfileStructA
--*/
BOOL APIHOOK(WritePrivateProfileSectionA)(
LPCSTR lpAppName, // section name
LPCSTR lpString, // data
LPCSTR lpFileName // file name
)
{
char * strCorrect = ProfileCorrectPath(lpFileName, "WritePrivateProfileSectionA");
BOOL returnValue = ORIGINAL_API(WritePrivateProfileSectionA)(lpAppName, lpString, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for WritePrivateProfileSectionW
--*/
BOOL APIHOOK(WritePrivateProfileSectionW)(
LPCWSTR lpAppName, // section name
LPCWSTR lpString, // data
LPCWSTR lpFileName // file name
)
{
WCHAR * strCorrect = ProfileCorrectPath(lpFileName, "WritePrivateProfileSectionW");
BOOL returnValue = ORIGINAL_API(WritePrivateProfileSectionW)(lpAppName, lpString, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for WritePrivateProfileStringA
--*/
BOOL APIHOOK(WritePrivateProfileStringA)(
LPCSTR lpAppName, // section name
LPCSTR lpKeyName, // key name
LPCSTR lpString, // string to add
LPCSTR lpFileName // initialization file
)
{
char * strCorrect = ProfileCorrectPath(lpFileName, "WritePrivateProfileStringA");
BOOL returnValue = ORIGINAL_API(WritePrivateProfileStringA)(lpAppName, lpKeyName, lpString, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for WritePrivateProfileStringW
--*/
BOOL APIHOOK(WritePrivateProfileStringW)(
LPCWSTR lpAppName, // section name
LPCWSTR lpKeyName, // key name
LPCWSTR lpString, // string to add
LPCWSTR lpFileName // initialization file
)
{
WCHAR * strCorrect = ProfileCorrectPath(lpFileName, "WritePrivateProfileStringW");
BOOL returnValue = ORIGINAL_API(WritePrivateProfileStringW)(lpAppName, lpKeyName, lpString, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for WritePrivateProfileStructA
--*/
BOOL APIHOOK(WritePrivateProfileStructA)(
LPCSTR lpszSection, // section name
LPCSTR lpszKey, // key name
LPVOID lpStruct, // data buffer
UINT uSizeStruct, // size of data buffer
LPCSTR lpFileName // initialization file
)
{
char * strCorrect = ProfileCorrectPath(lpFileName, "WritePrivateProfileStructA");
BOOL returnValue = ORIGINAL_API(WritePrivateProfileStructA)(lpszSection, lpszKey, lpStruct, uSizeStruct, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for WritePrivateProfileStructW
--*/
BOOL APIHOOK(WritePrivateProfileStructW)(
LPCWSTR lpszSection, // section name
LPCWSTR lpszKey, // key name
LPVOID lpStruct, // data buffer
UINT uSizeStruct, // size of data buffer
LPCWSTR lpFileName // initialization file
)
{
WCHAR * strCorrect = ProfileCorrectPath(lpFileName, "WritePrivateProfileStructW");
BOOL returnValue = ORIGINAL_API(WritePrivateProfileStructW)(lpszSection, lpszKey, lpStruct, uSizeStruct, strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Convert Win9x paths to WinNT paths for IShellLinkA::SetArguments
--*/
HRESULT COMHOOK(IShellLinkA, SetArguments)( PVOID pThis, LPCSTR pszArgs )
{
HRESULT hrReturn = E_FAIL;
char * strCorrect = CorrectPath(pszArgs, "IShellLinkA::SetArguments", FALSE);
_pfn_IShellLinkA_SetArguments pfnOld = ORIGINAL_COM(IShellLinkA, SetArguments, pThis);
if (pfnOld)
hrReturn = (*pfnOld)( pThis, strCorrect );
CorrectFree(strCorrect, pszArgs);
return hrReturn;
}
/*++
Convert Win9x paths to WinNT paths for IShellLinkW::SetArguments
--*/
HRESULT COMHOOK(IShellLinkW, SetArguments)( PVOID pThis, LPCWSTR pszArgs )
{
HRESULT hrReturn = E_FAIL;
WCHAR * strCorrect = CorrectPath(pszArgs, "IShellLinkA::SetArguments", FALSE);
_pfn_IShellLinkW_SetArguments pfnOld = ORIGINAL_COM(IShellLinkW, SetArguments, pThis);
if(pfnOld)
hrReturn = (*pfnOld)( pThis, strCorrect );
CorrectFree(strCorrect, pszArgs);
return hrReturn;
}
/*++
Convert Win9x paths to WinNT paths for IShellLinkA::SetIconLocation
--*/
HRESULT COMHOOK(IShellLinkA, SetIconLocation)(PVOID pThis, LPCSTR pszIconLocation, int nIcon )
{
HRESULT hrReturn = E_FAIL;
char * strCorrect = CorrectPath(pszIconLocation, "IShellLinkA::SetIconLocation");
_pfn_IShellLinkA_SetIconLocation pfnOld = ORIGINAL_COM(IShellLinkA, SetIconLocation, pThis);
if (pfnOld)
hrReturn = (*pfnOld)( pThis, strCorrect, nIcon );
CorrectFree(strCorrect, pszIconLocation);
return hrReturn;
}
/*++
Convert Win9x paths to WinNT paths for IShellLinkW::SetIconLocation
--*/
HRESULT COMHOOK(IShellLinkW, SetIconLocation)(PVOID pThis, LPCWSTR pszIconLocation, int nIcon )
{
HRESULT hrReturn = E_FAIL;
WCHAR * strCorrect = CorrectPath(pszIconLocation, "IShellLinkW::SetIconLocation");
_pfn_IShellLinkW_SetIconLocation pfnOld = ORIGINAL_COM(IShellLinkW, SetIconLocation, pThis);
if(pfnOld)
hrReturn = (*pfnOld)( pThis, strCorrect, nIcon );
CorrectFree(strCorrect, pszIconLocation);
return hrReturn;
}
/*++
Convert Win9x paths to WinNT paths for IShellLinkA::SetPath
--*/
HRESULT COMHOOK(IShellLinkA, SetPath)(PVOID pThis,
LPCSTR pszFile )
{
HRESULT hrReturn = E_FAIL;
char * strCorrect = CorrectPath(pszFile, "IShellLinkA::SetPath");
_pfn_IShellLinkA_SetPath pfnOld = ORIGINAL_COM(IShellLinkA, SetPath, pThis);
if (pfnOld)
hrReturn = (*pfnOld)( pThis, strCorrect );
CorrectFree(strCorrect, pszFile);
return hrReturn;
}
/*++
Convert Win9x paths to WinNT paths for IShellLinkW::SetPath
--*/
HRESULT COMHOOK(IShellLinkW, SetPath)(PVOID pThis,
LPCWSTR pszFile )
{
HRESULT hrReturn = E_FAIL;
WCHAR * strCorrect = CorrectPath(pszFile, "IShellLinkW::SetPath");
_pfn_IShellLinkW_SetPath pfnOld = ORIGINAL_COM(IShellLinkW, SetPath, pThis);
if (pfnOld)
hrReturn = (*pfnOld)( pThis, strCorrect );
CorrectFree(strCorrect, pszFile);
return hrReturn;
}
/*++
Convert Win9x paths to WinNT paths for IPersistFile::Save
--*/
HRESULT COMHOOK(IPersistFile, Save)(PVOID pThis,
LPCOLESTR pszFileName,
BOOL fRemember)
{
HRESULT hrReturn = E_FAIL;
WCHAR * strCorrect = CorrectPath(pszFileName, "IPersistFile_Save");
_pfn_IPersistFile_Save pfnOld = ORIGINAL_COM(IPersistFile, Save, pThis);
if (pfnOld)
hrReturn = (*pfnOld)( pThis, strCorrect, fRemember );
CorrectFree(strCorrect, pszFileName);
return hrReturn;
}
BOOL APIHOOK(CopyFileA)(
LPCSTR lpExistingFileName, // name of an existing file
LPCSTR lpNewFileName, // name of new file
BOOL bFailIfExists // operation if file exists
)
{
char * strExistingCorrect = CorrectPath(lpExistingFileName, "CopyFileA");
char * strNewCorrect = CorrectPath(lpNewFileName, "CopyFileA");
BOOL returnValue = ORIGINAL_API(CopyFileA)(strExistingCorrect, strNewCorrect, bFailIfExists);
CorrectFree(strExistingCorrect, lpExistingFileName);
CorrectFree(strNewCorrect, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(CopyFileW)(
LPCWSTR lpExistingFileName, // name of an existing file
LPCWSTR lpNewFileName, // name of new file
BOOL bFailIfExists // operation if file exists
)
{
WCHAR * strExistingCorrect = CorrectPath(lpExistingFileName, "CopyFileW");
WCHAR * strNewCorrect = CorrectPath(lpNewFileName, "CopyFileW");
BOOL returnValue = ORIGINAL_API(CopyFileW)(strExistingCorrect, strNewCorrect, bFailIfExists);
CorrectFree(strExistingCorrect, lpExistingFileName);
CorrectFree(strNewCorrect, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(CopyFileExA)(
LPCSTR lpExistingFileName, // name of existing file
LPCSTR lpNewFileName, // name of new file
LPPROGRESS_ROUTINE lpProgressRoutine, // callback function
LPVOID lpData, // callback parameter
LPBOOL pbCancel, // cancel status
DWORD dwCopyFlags // copy options
)
{
char * strExistingCorrect = CorrectPath(lpExistingFileName, "CopyFileExA");
char * strNewCorrect = CorrectPath(lpNewFileName, "CopyFileExA");
BOOL returnValue = ORIGINAL_API(CopyFileExA)(strExistingCorrect, strNewCorrect, lpProgressRoutine, lpData, pbCancel, dwCopyFlags);
CorrectFree(strExistingCorrect, lpExistingFileName);
CorrectFree(strNewCorrect, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(CopyFileExW)(
LPCWSTR lpExistingFileName, // name of existing file
LPCWSTR lpNewFileName, // name of new file
LPPROGRESS_ROUTINE lpProgressRoutine, // callback function
LPVOID lpData, // callback parameter
LPBOOL pbCancel, // cancel status
DWORD dwCopyFlags // copy options
)
{
WCHAR * strExistingCorrect = CorrectPath(lpExistingFileName, "CopyFileExW");
WCHAR * strNewCorrect = CorrectPath(lpNewFileName, "CopyFileExW");
BOOL returnValue = ORIGINAL_API(CopyFileExW)(strExistingCorrect, strNewCorrect, lpProgressRoutine, lpData, pbCancel, dwCopyFlags);
CorrectFree(strExistingCorrect, lpExistingFileName);
CorrectFree(strNewCorrect, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(CreateDirectoryA)(
LPCSTR lpPathName, // directory name
LPSECURITY_ATTRIBUTES lpSecurityAttributes // SD
)
{
char * strCorrect = CorrectPath(lpPathName, "CreateDirectoryA");
BOOL returnValue = ORIGINAL_API(CreateDirectoryA)(strCorrect, lpSecurityAttributes);
CorrectFree(strCorrect, lpPathName);
return returnValue;
}
BOOL APIHOOK(CreateDirectoryW)(
LPCWSTR lpPathName, // directory name
LPSECURITY_ATTRIBUTES lpSecurityAttributes // SD
)
{
WCHAR * strCorrect = CorrectPath(lpPathName, "CreateDirectoryW");
BOOL returnValue = ORIGINAL_API(CreateDirectoryW)(strCorrect, lpSecurityAttributes);
CorrectFree(strCorrect, lpPathName);
return returnValue;
}
BOOL APIHOOK(CreateDirectoryExA)(
LPCSTR lpTemplateDirectory, // template directory
LPCSTR lpNewDirectory, // directory name
LPSECURITY_ATTRIBUTES lpSecurityAttributes // SD
)
{
char * strTemplateCorrect = CorrectPath(lpTemplateDirectory, "CreateDirectoryExA");
char * strNewCorrect = CorrectPath(lpNewDirectory, "CreateDirectoryExA");
BOOL returnValue = ORIGINAL_API(CreateDirectoryExA)(strTemplateCorrect, strNewCorrect, lpSecurityAttributes);
CorrectFree(strTemplateCorrect, lpTemplateDirectory);
CorrectFree(strNewCorrect, lpNewDirectory);
return returnValue;
}
BOOL APIHOOK(CreateDirectoryExW)(
LPCWSTR lpTemplateDirectory, // template directory
LPCWSTR lpNewDirectory, // directory name
LPSECURITY_ATTRIBUTES lpSecurityAttributes // SD
)
{
WCHAR * strTemplateCorrect = CorrectPath(lpTemplateDirectory, "CreateDirectoryExW");
WCHAR * strNewCorrect = CorrectPath(lpNewDirectory, "CreateDirectoryExW");
BOOL returnValue = ORIGINAL_API(CreateDirectoryExW)(strTemplateCorrect, strNewCorrect, lpSecurityAttributes);
CorrectFree(strTemplateCorrect, lpTemplateDirectory);
CorrectFree(strNewCorrect, lpNewDirectory);
return returnValue;
}
HANDLE APIHOOK(CreateFileA)(
LPCSTR lpFileName, // file name
DWORD dwDesiredAccess, // access mode
DWORD dwShareMode, // share mode
LPSECURITY_ATTRIBUTES lpSecurityAttributes, // SD
DWORD dwCreationDisposition, // how to create
DWORD dwFlagsAndAttributes, // file attributes
HANDLE hTemplateFile // handle to template file
)
{
char * strCorrect = CorrectPath(lpFileName, "CreateFileA");
HANDLE returnValue = ORIGINAL_API(CreateFileA)(strCorrect,
dwDesiredAccess,
dwShareMode,
lpSecurityAttributes,
dwCreationDisposition,
dwFlagsAndAttributes,
hTemplateFile);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
HANDLE APIHOOK(CreateFileW)(
LPCWSTR lpFileName, // file name
DWORD dwDesiredAccess, // access mode
DWORD dwShareMode, // share mode
LPSECURITY_ATTRIBUTES lpSecurityAttributes, // SD
DWORD dwCreationDisposition, // how to create
DWORD dwFlagsAndAttributes, // file attributes
HANDLE hTemplateFile // handle to template file
)
{
WCHAR * strCorrect = CorrectPath(lpFileName, "CreateFileW");
HANDLE returnValue = ORIGINAL_API(CreateFileW)(
strCorrect,
dwDesiredAccess,
dwShareMode,
lpSecurityAttributes,
dwCreationDisposition,
dwFlagsAndAttributes,
hTemplateFile);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
BOOL APIHOOK(DeleteFileA)(
LPCSTR lpFileName // file name
)
{
char * strCorrect = CorrectPath(lpFileName, "DeleteFileA");
BOOL returnValue = ORIGINAL_API(DeleteFileA)(strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
BOOL APIHOOK(DeleteFileW)(
LPCWSTR lpFileName // file name
)
{
WCHAR * strCorrect = CorrectPath(lpFileName, "DeleteFileW");
BOOL returnValue = ORIGINAL_API(DeleteFileW)(strCorrect);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
/*++
Win9xPath corrections will strip a trailing . from the end of a search string.
As a path, the . is not significant, but as a wildcard it is important--the
difference between finding files without an extension and finding all files
in the directory.
--*/
char * FindFirstFileCorrectPath(const char * uncorrect, const char * debugMsg, BOOL bMassagePath = g_bW9xPath)
{
char * strCorrect = CorrectPath(uncorrect, NULL, bMassagePath);
if (bMassagePath && uncorrect != strCorrect)
{
char * returnString = NULL;
CSTRING_TRY
{
CString csUncorrect(uncorrect);
CString csCorrect(strCorrect);
CString csUncorrectLast;
CString csCorrectLast;
csUncorrect.GetLastPathComponent(csUncorrectLast);
csCorrect.GetLastPathComponent(csCorrectLast);
if (csUncorrectLast.Compare(L"*.") == 0 && csCorrectLast.Compare(L"*") == 0)
{
csCorrectLast += L".";
returnString = csCorrectLast.ReleaseAnsi();
}
}
CSTRING_CATCH
{
// Some CString error occured, make sure returnString is NULL
if (returnString != NULL)
{
free(returnString);
}
returnString = NULL;
}
if (returnString)
{
CorrectFree(strCorrect, uncorrect);
strCorrect = returnString;
}
}
if (debugMsg)
{
DebugSpew(uncorrect, strCorrect, debugMsg);
}
return strCorrect;
}
/*++
Win9xPath corrections will strip a trailing . from the end of a search string.
As a path, the . is not significant, but as a wildcard it is important--the
difference between finding files without an extension and finding all files
in the directory.
--*/
WCHAR * FindFirstFileCorrectPath(const WCHAR * uncorrect, const char * debugMsg, BOOL bMassagePath = g_bW9xPath)
{
WCHAR * strCorrect = CorrectPath(uncorrect, NULL, bMassagePath);
if (bMassagePath && uncorrect != strCorrect)
{
WCHAR * returnString = NULL;
CSTRING_TRY
{
CString csUncorrect(uncorrect);
CString csCorrect(strCorrect);
CString csUncorrectLast;
CString csCorrectLast;
csUncorrect.GetLastPathComponent(csUncorrectLast);
csCorrect.GetLastPathComponent(csCorrectLast);
if (csUncorrectLast.Compare(L"*.") == 0 && csCorrectLast.Compare(L"*") == 0)
{
csCorrectLast += L".";
// Manually copy the buffer
size_t nBytes = (csCorrectLast.GetLength() + 1) * sizeof(WCHAR);
returnString = (WCHAR*) malloc(nBytes);
if (returnString)
{
memcpy(returnString, csCorrectLast.Get(), nBytes);
}
}
}
CSTRING_CATCH
{
// Some CString error occured, make sure returnString is NULL
if (returnString != NULL)
{
free(returnString);
}
returnString = NULL;
}
if (returnString)
{
CorrectFree(strCorrect, uncorrect);
strCorrect = returnString;
}
}
if (debugMsg)
{
DebugSpew(uncorrect, strCorrect, debugMsg);
}
return strCorrect;
}
HANDLE APIHOOK(FindFirstFileA)(
LPCSTR lpFileName, // file name
LPWIN32_FIND_DATAA lpFindFileData // data buffer
)
{
char * strCorrect = FindFirstFileCorrectPath(lpFileName, "FindFirstFileA");
HANDLE returnValue = ORIGINAL_API(FindFirstFileA)(strCorrect, lpFindFileData);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
HANDLE APIHOOK(FindFirstFileW)(
LPCWSTR lpFileName, // file name
LPWIN32_FIND_DATAW lpFindFileData // data buffer
)
{
WCHAR * strCorrect = FindFirstFileCorrectPath(lpFileName, "FindFirstFileW");
HANDLE returnValue = ORIGINAL_API(FindFirstFileW)(strCorrect, lpFindFileData);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
HANDLE APIHOOK(FindFirstFileExA)(
LPCSTR lpFileName, // file name
FINDEX_INFO_LEVELS fInfoLevelId, // information level
LPVOID lpFindFileData, // information buffer
FINDEX_SEARCH_OPS fSearchOp, // filtering type
LPVOID lpSearchFilter, // search criteria
DWORD dwAdditionalFlags // additional search control
)
{
char * strCorrect = FindFirstFileCorrectPath(lpFileName, "FindFirstFileExA");
HANDLE returnValue = ORIGINAL_API(FindFirstFileExA)(
strCorrect,
fInfoLevelId,
lpFindFileData,
fSearchOp,
lpSearchFilter,
dwAdditionalFlags);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
HANDLE APIHOOK(FindFirstFileExW)(
LPCWSTR lpFileName, // file name
FINDEX_INFO_LEVELS fInfoLevelId, // information level
LPVOID lpFindFileData, // information buffer
FINDEX_SEARCH_OPS fSearchOp, // filtering type
LPVOID lpSearchFilter, // search criteria
DWORD dwAdditionalFlags // additional search control
)
{
WCHAR * strCorrect = FindFirstFileCorrectPath(lpFileName, "FindFirstFileExW");
HANDLE returnValue = ORIGINAL_API(FindFirstFileExW)(
strCorrect,
fInfoLevelId,
lpFindFileData,
fSearchOp,
lpSearchFilter,
dwAdditionalFlags);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
BOOL APIHOOK(GetBinaryTypeA)(
LPCSTR lpApplicationName, // full file path
LPDWORD lpBinaryType // binary type information
)
{
char * strCorrect = CorrectPath(lpApplicationName, "GetBinaryTypeA");
BOOL returnValue = ORIGINAL_API(GetBinaryTypeA)(strCorrect, lpBinaryType);
CorrectFree(strCorrect, lpApplicationName);
return returnValue;
}
BOOL APIHOOK(GetBinaryTypeW)(
LPCWSTR lpApplicationName, // full file path
LPDWORD lpBinaryType // binary type information
)
{
WCHAR * strCorrect = CorrectPath(lpApplicationName, "GetBinaryTypeW");
BOOL returnValue = ORIGINAL_API(GetBinaryTypeW)(strCorrect, lpBinaryType);
CorrectFree(strCorrect, lpApplicationName);
return returnValue;
}
BOOL APIHOOK(MoveFileA)(
LPCSTR lpExistingFileName, // file name
LPCSTR lpNewFileName // new file name
)
{
char * strCorrectExisting = CorrectPath(lpExistingFileName, "MoveFileA");
char * strCorrectNew = CorrectPath(lpNewFileName, "MoveFileA");
BOOL returnValue = ORIGINAL_API(MoveFileA)(strCorrectExisting, strCorrectNew);
CorrectFree(strCorrectExisting, lpExistingFileName);
CorrectFree(strCorrectNew, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(MoveFileW)(
LPCWSTR lpExistingFileName, // file name
LPCWSTR lpNewFileName // new file name
)
{
WCHAR * strCorrectExisting = CorrectPath(lpExistingFileName, "MoveFileW");
WCHAR * strCorrectNew = CorrectPath(lpNewFileName, "MoveFileW");
BOOL returnValue = ORIGINAL_API(MoveFileW)(strCorrectExisting, strCorrectNew);
CorrectFree(strCorrectExisting, lpExistingFileName);
CorrectFree(strCorrectNew, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(MoveFileExA)(
LPCSTR lpExistingFileName, // file name
LPCSTR lpNewFileName, // new file name
DWORD dwFlags // move options
)
{
char * strCorrectExisting = CorrectPath(lpExistingFileName, "MoveFileExA");
char * strCorrectNew = CorrectPath(lpNewFileName, "MoveFileExA");
BOOL returnValue = ORIGINAL_API(MoveFileExA)(strCorrectExisting, strCorrectNew, dwFlags);
CorrectFree(strCorrectExisting, lpExistingFileName);
CorrectFree(strCorrectNew, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(MoveFileExW)(
LPCWSTR lpExistingFileName, // file name
LPCWSTR lpNewFileName, // new file name
DWORD dwFlags // move options
)
{
WCHAR * strCorrectExisting = CorrectPath(lpExistingFileName, "MoveFileExW");
WCHAR * strCorrectNew = CorrectPath(lpNewFileName, "MoveFileExW");
BOOL returnValue = ORIGINAL_API(MoveFileExW)(strCorrectExisting, strCorrectNew, dwFlags);
CorrectFree(strCorrectExisting, lpExistingFileName);
CorrectFree(strCorrectNew, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(MoveFileWithProgressA)(
LPCSTR lpExistingFileName, // file name
LPCSTR lpNewFileName, // new file name
LPPROGRESS_ROUTINE lpProgressRoutine, // callback function
LPVOID lpData, // parameter for callback
DWORD dwFlags // move options
)
{
char * strCorrectExisting = CorrectPath(lpExistingFileName, "MoveFileWithProgressA");
char * strCorrectNew = CorrectPath(lpNewFileName, "MoveFileWithProgressA");
BOOL returnValue = ORIGINAL_API(MoveFileWithProgressA)(strCorrectExisting, strCorrectNew, lpProgressRoutine, lpData, dwFlags);
CorrectFree(strCorrectExisting, lpExistingFileName);
CorrectFree(strCorrectNew, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(MoveFileWithProgressW)(
LPCWSTR lpExistingFileName, // file name
LPCWSTR lpNewFileName, // new file name
LPPROGRESS_ROUTINE lpProgressRoutine, // callback function
LPVOID lpData, // parameter for callback
DWORD dwFlags // move options
)
{
WCHAR * strCorrectExisting = CorrectPath(lpExistingFileName, "MoveFileW");
WCHAR * strCorrectNew = CorrectPath(lpNewFileName, "MoveFileW");
BOOL returnValue = ORIGINAL_API(MoveFileWithProgressW)(strCorrectExisting, strCorrectNew, lpProgressRoutine, lpData, dwFlags);
CorrectFree(strCorrectExisting, lpExistingFileName);
CorrectFree(strCorrectNew, lpNewFileName);
return returnValue;
}
BOOL APIHOOK(RemoveDirectoryA)(
LPCSTR lpPathName // directory name
)
{
char * strCorrect = CorrectPath(lpPathName, "RemoveDirectoryA");
BOOL returnValue = ORIGINAL_API(RemoveDirectoryA)(strCorrect);
CorrectFree(strCorrect, lpPathName);
return returnValue;
}
BOOL APIHOOK(RemoveDirectoryW)(
LPCWSTR lpPathName // directory name
)
{
WCHAR * strCorrect = CorrectPath(lpPathName, "RemoveDirectoryW");
BOOL returnValue = ORIGINAL_API(RemoveDirectoryW)(strCorrect);
CorrectFree(strCorrect, lpPathName);
return returnValue;
}
BOOL APIHOOK(SetCurrentDirectoryA)(
LPCSTR lpPathName // new directory name
)
{
char * strCorrect = CorrectPath(lpPathName, "SetCurrentDirectoryA");
BOOL returnValue = ORIGINAL_API(SetCurrentDirectoryA)(strCorrect);
CorrectFree(strCorrect, lpPathName);
return returnValue;
}
BOOL APIHOOK(SetCurrentDirectoryW)(
LPCWSTR lpPathName // new directory name
)
{
WCHAR * strCorrect = CorrectPath(lpPathName, "SetCurrentDirectoryW");
BOOL returnValue = ORIGINAL_API(SetCurrentDirectoryW)(strCorrect);
CorrectFree(strCorrect, lpPathName);
return returnValue;
}
HFILE APIHOOK(OpenFile)(
LPCSTR lpFileName, // file name
LPOFSTRUCT lpReOpenBuff, // file information
UINT uStyle // action and attributes
)
{
char * strCorrect = CorrectPath(lpFileName, "OpenFile");
HFILE returnValue = ORIGINAL_API(OpenFile)(strCorrect, lpReOpenBuff, uStyle);
CorrectFree(strCorrect, lpFileName);
return returnValue;
}
LONG APIHOOK(RegSetValueA)(
HKEY hKey, // handle to key
LPCSTR lpSubKey, // subkey name
DWORD dwType, // information type
LPCSTR lpData, // value data
DWORD cbData // size of value data
)
{
char * strCorrect = CorrectPath(lpData, "RegSetValueA", FALSE);
// Data key is length of string *not* including null byte.
if (strCorrect)
{
cbData = strlen(strCorrect);
}
LONG returnValue = ORIGINAL_API(RegSetValueA)(hKey, lpSubKey, dwType, strCorrect, cbData);
CorrectFree(strCorrect, lpData);
return returnValue;
}
LONG APIHOOK(RegSetValueW)(
HKEY hKey, // handle to key
LPCWSTR lpSubKey, // subkey name
DWORD dwType, // information type
LPCWSTR lpData, // value data
DWORD cbData // size of value data
)
{
WCHAR * strCorrect = CorrectPath(lpData, "RegSetValueW", FALSE);
// Data key is length of string *not* including null byte.
if (strCorrect)
cbData = wcslen(strCorrect);
LONG returnValue = ORIGINAL_API(RegSetValueW)(hKey, lpSubKey, dwType, strCorrect, cbData);
CorrectFree(strCorrect, lpData);
return returnValue;
}
LONG APIHOOK(RegSetValueExA)(
HKEY hKey, // handle to key
LPCSTR lpValueName, // value name
DWORD Reserved, // reserved
DWORD dwType, // value type
CONST BYTE *lpData, // value data
DWORD cbData // size of value data
)
{
if (dwType == REG_SZ)
{
char * strCorrect = CorrectPath((const char *)lpData, "RegSetValueExA", FALSE);
// Data key is length of string *including* null byte.
if (strCorrect)
{
cbData = strlen(strCorrect) + 1;
}
LONG returnValue = ORIGINAL_API(RegSetValueExA)(
hKey, // handle to key
lpValueName, // value name
Reserved, // reserved
dwType, // value type
(CONST BYTE *)strCorrect, // value data
cbData);
CorrectFree(strCorrect, (const char *)lpData);
return returnValue;
}
else
{
// Pass data on through
LONG returnValue = ORIGINAL_API(RegSetValueExA)(
hKey, // handle to key
lpValueName, // value name
Reserved, // reserved
dwType, // value type
lpData, // value data
cbData);
return returnValue;
}
}
LONG APIHOOK(RegSetValueExW)(
HKEY hKey, // handle to key
LPCWSTR lpValueName, // value name
DWORD Reserved, // reserved
DWORD dwType, // value type
CONST BYTE *lpData, // value data
DWORD cbData // size of value data
)
{
if (dwType == REG_SZ)
{
WCHAR * strCorrect = CorrectPath((const WCHAR*)lpData, "RegSetValueExW", FALSE);
// Data key is length of string *including* null byte.
if (strCorrect)
{
cbData = wcslen(strCorrect) + 1;
}
LONG returnValue = ORIGINAL_API(RegSetValueExW)(
hKey, // handle to key
lpValueName, // value name
Reserved, // reserved
dwType, // value type
(CONST BYTE *)strCorrect, // value data
cbData);
CorrectFree(strCorrect, (const WCHAR *)lpData);
return returnValue;
}
else
{
// Pass data on through
LONG returnValue = ORIGINAL_API(RegSetValueExW)(
hKey, // handle to key
lpValueName, // value name
Reserved, // reserved
dwType, // value type
lpData, // value data
cbData);
return returnValue;
}
}
HFILE APIHOOK(_lopen)(
LPCSTR lpPathName,
int iReadWrite
)
{
char * strCorrect = CorrectPath(lpPathName, "lopen");
HFILE returnValue = ORIGINAL_API(_lopen)(strCorrect, iReadWrite);
CorrectFree(strCorrect, lpPathName);
return returnValue;
}
HFILE APIHOOK(_lcreat)(
LPCSTR lpPathName,
int iAttribute
)
{
char * strCorrect = CorrectPath(lpPathName, "lcreat");
HFILE returnValue = ORIGINAL_API(_lcreat)(strCorrect, iAttribute);
CorrectFree(strCorrect, lpPathName);
return returnValue;
}
HANDLE
APIHOOK(LoadImageA)(
HINSTANCE hinst, // handle to instance
LPCSTR lpszName, // name or identifier of the image
UINT uType, // image type
int cxDesired, // desired width
int cyDesired, // desired height
UINT fuLoad // load options
)
{
HANDLE returnValue = NULL;
// Another one of those incredibly overloaded API's:
// lpszName is not always a path
if ((uType == IMAGE_BITMAP) &&
(fuLoad & LR_LOADFROMFILE) &&
!IsBadStringPtrA(lpszName, 1))
{
char * strCorrect = CorrectPath(lpszName, "LoadImageA");
returnValue = ORIGINAL_API(LoadImageA)(hinst, strCorrect, uType, cxDesired, cyDesired, fuLoad);
CorrectFree(strCorrect, lpszName);
}
else
{
returnValue = ORIGINAL_API(LoadImageA)(hinst, lpszName, uType, cxDesired, cyDesired, fuLoad);
}
return returnValue;
}
IMPLEMENT_COMSERVER_HOOK(SHELL32)
BOOL
NOTIFY_FUNCTION(
DWORD fdwReason
)
{
BOOL bSuccess = TRUE;
if (fdwReason == DLL_PROCESS_ATTACH)
{
bSuccess = ParseCommandLine(COMMAND_LINE);
if (bSuccess)
{
// Create g_AllocatedPathCorrector
return InitPathcorrectorClass();
}
}
else if (fdwReason == SHIM_STATIC_DLLS_INITIALIZED)
{
// It is now safe for us to do our work
g_PathCorrector = g_AllocatedPathCorrector;
InitializePathCorrections();
}
return bSuccess;
}
/*++
Register hooked functions
--*/
HOOK_BEGIN
CALL_NOTIFY_FUNCTION
if (g_bCreateProcessRoutines)
{
APIHOOK_ENTRY(KERNEL32.DLL, CreateProcessA)
APIHOOK_ENTRY(KERNEL32.DLL, CreateProcessW)
APIHOOK_ENTRY(KERNEL32.DLL, WinExec)
APIHOOK_ENTRY(SHELL32.DLL, ShellExecuteA)
APIHOOK_ENTRY(SHELL32.DLL, ShellExecuteW)
APIHOOK_ENTRY(SHELL32.DLL, ShellExecuteExA)
APIHOOK_ENTRY(SHELL32.DLL, ShellExecuteExW)
}
if (g_bGetCommandLineRoutines)
{
APIHOOK_ENTRY(KERNEL32.DLL, GetCommandLineA)
APIHOOK_ENTRY(KERNEL32.DLL, GetCommandLineW)
}
if (g_bProfileRoutines)
{
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileIntA)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileIntW)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileSectionA)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileSectionW)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileSectionNamesA)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileSectionNamesW)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileStringA)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileStringW)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileStructA)
APIHOOK_ENTRY(KERNEL32.DLL, GetPrivateProfileStructW)
APIHOOK_ENTRY(KERNEL32.DLL, WritePrivateProfileSectionA)
APIHOOK_ENTRY(KERNEL32.DLL, WritePrivateProfileSectionW)
APIHOOK_ENTRY(KERNEL32.DLL, WritePrivateProfileStringA)
APIHOOK_ENTRY(KERNEL32.DLL, WritePrivateProfileStringW)
APIHOOK_ENTRY(KERNEL32.DLL, WritePrivateProfileStructA)
APIHOOK_ENTRY(KERNEL32.DLL, WritePrivateProfileStructW)
}
if (g_bFileRoutines)
{
APIHOOK_ENTRY(KERNEL32.DLL, CopyFileA)
APIHOOK_ENTRY(KERNEL32.DLL, CopyFileW)
APIHOOK_ENTRY(KERNEL32.DLL, CopyFileExA)
APIHOOK_ENTRY(KERNEL32.DLL, CopyFileExW)
APIHOOK_ENTRY(KERNEL32.DLL, CreateDirectoryA)
APIHOOK_ENTRY(KERNEL32.DLL, CreateDirectoryW)
APIHOOK_ENTRY(KERNEL32.DLL, CreateDirectoryExA)
APIHOOK_ENTRY(KERNEL32.DLL, CreateDirectoryExW)
APIHOOK_ENTRY(KERNEL32.DLL, CreateFileA)
APIHOOK_ENTRY(KERNEL32.DLL, CreateFileW)
APIHOOK_ENTRY(KERNEL32.DLL, DeleteFileA)
APIHOOK_ENTRY(KERNEL32.DLL, DeleteFileW)
APIHOOK_ENTRY(KERNEL32.DLL, FindFirstFileA)
APIHOOK_ENTRY(KERNEL32.DLL, FindFirstFileW)
APIHOOK_ENTRY(KERNEL32.DLL, FindFirstFileExA)
APIHOOK_ENTRY(KERNEL32.DLL, FindFirstFileExW)
APIHOOK_ENTRY(KERNEL32.DLL, GetBinaryTypeA)
APIHOOK_ENTRY(KERNEL32.DLL, GetBinaryTypeW)
APIHOOK_ENTRY(KERNEL32.DLL, GetFileAttributesA)
APIHOOK_ENTRY(KERNEL32.DLL, GetFileAttributesW)
APIHOOK_ENTRY(KERNEL32.DLL, GetFileAttributesExA)
APIHOOK_ENTRY(KERNEL32.DLL, GetFileAttributesExW)
APIHOOK_ENTRY(KERNEL32.DLL, SetFileAttributesA)
APIHOOK_ENTRY(KERNEL32.DLL, SetFileAttributesW)
APIHOOK_ENTRY(KERNEL32.DLL, MoveFileA)
APIHOOK_ENTRY(KERNEL32.DLL, MoveFileW)
APIHOOK_ENTRY(KERNEL32.DLL, MoveFileExA)
APIHOOK_ENTRY(KERNEL32.DLL, MoveFileExW)
APIHOOK_ENTRY(KERNEL32.DLL, MoveFileWithProgressA)
APIHOOK_ENTRY(KERNEL32.DLL, MoveFileWithProgressW)
APIHOOK_ENTRY(KERNEL32.DLL, RemoveDirectoryA)
APIHOOK_ENTRY(KERNEL32.DLL, RemoveDirectoryW)
APIHOOK_ENTRY(KERNEL32.DLL, SetCurrentDirectoryA)
APIHOOK_ENTRY(KERNEL32.DLL, SetCurrentDirectoryW)
APIHOOK_ENTRY(KERNEL32.DLL, OpenFile)
// 16 bit compatibility file routines
APIHOOK_ENTRY(KERNEL32.DLL, _lopen)
APIHOOK_ENTRY(KERNEL32.DLL, _lcreat)
}
if (g_bRegSetValueRoutines)
{
APIHOOK_ENTRY(ADVAPI32.DLL, RegSetValueA)
APIHOOK_ENTRY(ADVAPI32.DLL, RegSetValueW)
APIHOOK_ENTRY(ADVAPI32.DLL, RegSetValueExA)
APIHOOK_ENTRY(ADVAPI32.DLL, RegSetValueExW)
}
if (g_bShellLinkRoutines)
{
APIHOOK_ENTRY_COMSERVER(SHELL32)
COMHOOK_ENTRY(ShellLink, IShellLinkA, SetPath, 20)
COMHOOK_ENTRY(ShellLink, IShellLinkW, SetPath, 20)
COMHOOK_ENTRY(ShellLink, IShellLinkA, SetArguments, 11)
COMHOOK_ENTRY(ShellLink, IShellLinkW, SetArguments, 11)
COMHOOK_ENTRY(ShellLink, IShellLinkA, SetIconLocation, 17)
COMHOOK_ENTRY(ShellLink, IShellLinkW, SetIconLocation, 17)
COMHOOK_ENTRY(ShellLink, IPersistFile, Save, 6)
}
if (g_bLoadImage)
{
APIHOOK_ENTRY(USER32.DLL, LoadImageA)
}
HOOK_END
IMPLEMENT_SHIM_END
Reference in New Issue Copy Permalink