603 lines
23 KiB
C
603 lines
23 KiB
C
// apphacks.c : Defines the entry point for the console application.
|
|
//
|
|
// This little utility is supposed to allow me a way to enter in data into
|
|
// Image File Execution Options without doing it by hand all the time. Used
|
|
// specifically for apphack flags and taking version info out of the EXE to see
|
|
// if a match exists
|
|
|
|
#define UNICODE 1
|
|
|
|
#include <windows.h>
|
|
#include <commdlg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <winver.h>
|
|
#include <apcompat.h>
|
|
|
|
|
|
|
|
|
|
|
|
#define MIN_VERSION_RESOURCE 512
|
|
#define IMAGE_EXEC_OPTIONS TEXT("software\\microsoft\\windows NT\\currentversion\\Image File Execution Options\\")
|
|
|
|
extern TCHAR* CheckExtension(TCHAR*);
|
|
extern VOID SetRegistryVal(TCHAR* , TCHAR* , PTCHAR,DWORD);
|
|
extern VOID DetailError1 (DWORD );
|
|
|
|
extern BOOLEAN g_fNotPermanent;
|
|
PVOID g_lpPrevRegSettings;
|
|
|
|
|
|
UINT uVersionInfo[5][8]={ {4,0,1381,VER_PLATFORM_WIN32_NT,3,0,0,0},
|
|
{4,0,1381,VER_PLATFORM_WIN32_NT,4,0,0,0},
|
|
{4,0,1381,VER_PLATFORM_WIN32_NT,5,0,0,0},
|
|
{4,10,1998,VER_PLATFORM_WIN32_WINDOWS,0,0,0,0},
|
|
{4,0,950,VER_PLATFORM_WIN32_WINDOWS,0,0,0,0}
|
|
};
|
|
|
|
PTCHAR pszVersionInfo[5]={
|
|
TEXT("Service Pack 3"),
|
|
TEXT("Service Pack 4"),
|
|
TEXT("Service Pack 5"),
|
|
TEXT(""),
|
|
TEXT("")
|
|
};
|
|
|
|
BOOLEAN g_GooAppendFlag;
|
|
|
|
|
|
VOID SetRegistryValGoo(TCHAR* szTitle, TCHAR* szVal,PUCHAR szBuffer,DWORD dwType,UINT length)
|
|
{
|
|
long lResult;
|
|
TCHAR szSubKey[MAX_PATH];
|
|
HKEY hKey;
|
|
|
|
wsprintf(szSubKey,
|
|
TEXT("software\\microsoft\\windows NT\\currentversion\\Image File Execution Options\\%s"),
|
|
szTitle);
|
|
|
|
lResult = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
|
|
szSubKey,
|
|
0,
|
|
TEXT("\0"),
|
|
0,
|
|
KEY_WRITE,
|
|
NULL,
|
|
&hKey,
|
|
NULL);
|
|
if(lResult == ERROR_SUCCESS)
|
|
{
|
|
|
|
RegSetValueEx(hKey,
|
|
szVal,
|
|
0,
|
|
dwType,
|
|
(CONST BYTE*)szBuffer,
|
|
length);
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
|
|
VOID DeleteRegistryValueGoo(TCHAR*szTitle)
|
|
{
|
|
long lResult;
|
|
TCHAR szSubKey[MAX_PATH];
|
|
HKEY hKey;
|
|
|
|
wsprintf(szSubKey,
|
|
TEXT("software\\microsoft\\windows NT\\currentversion\\Image File Execution Options\\%s"),
|
|
szTitle);
|
|
|
|
lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
szSubKey,
|
|
0,
|
|
KEY_WRITE,
|
|
&hKey
|
|
);
|
|
if(lResult == ERROR_SUCCESS)
|
|
{
|
|
RegDeleteValue(hKey,TEXT("ApplicationGoo") );
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
Check whether the registry contains an entry for "applicationgoo" for the given *.exe.
|
|
If it does, check the "resource info." to determine whether they are same.
|
|
If they are the same, don't worry, your work is already done. If not,
|
|
the new one needs to get appended to the old one.
|
|
*/
|
|
BOOLEAN CheckGooEntry(PVOID pVersionInfo,
|
|
PAPP_COMPAT_GOO pExistingVersionInfo,
|
|
BOOL fImageHasResourceInfo,
|
|
DWORD VersionInfoSize,
|
|
DWORD dwSize,
|
|
LARGE_INTEGER *pAppCompatFlag,
|
|
PAPP_VARIABLE_INFO pOsVersionInfo,
|
|
ULONG TotalVersionInfoLength,
|
|
TCHAR* pszPath // Executable path.
|
|
)
|
|
{
|
|
BOOLEAN fNeedAppend = FALSE;
|
|
// Added for the addition and deletion from the registry.
|
|
PAPP_COMPAT_GOO pReplaceAppCompatGoo;
|
|
PPRE_APP_COMPAT_INFO pAppCompatEntry, pStoredAppCompatEntry = NULL;
|
|
PPRE_APP_COMPAT_INFO pDestAppCompatEntry, pReplaceAppCompatEntry;
|
|
ULONG TotalGooLength, InputCompareLength, ReplaceCopyLength;
|
|
ULONG OutputCompareLength, CopyLength, OffSet;
|
|
PVOID ResourceInfo;
|
|
UINT iLoop = 0;
|
|
BOOL fMatchGot = FALSE;
|
|
PVOID pExistingAppCompatFlag;
|
|
PVOID pExistingOsVersionInfo;
|
|
BOOLEAN fAppCompatMatch = FALSE, fOsVersionMatch = FALSE;
|
|
TCHAR szTitle[MAX_PATH];
|
|
ULONG ReplaceGooLength;
|
|
|
|
pAppCompatEntry = pExistingVersionInfo ->AppCompatEntry;
|
|
TotalGooLength = pExistingVersionInfo ->dwTotalGooSize - \
|
|
sizeof(pExistingVersionInfo ->dwTotalGooSize);
|
|
//Loop till we get a matching entry in the registry.
|
|
while (TotalGooLength ){
|
|
InputCompareLength = pAppCompatEntry->dwResourceInfoSize;
|
|
ResourceInfo = pAppCompatEntry + 1;
|
|
|
|
if(fImageHasResourceInfo){
|
|
if( InputCompareLength > VersionInfoSize)
|
|
InputCompareLength = VersionInfoSize;
|
|
|
|
OutputCompareLength = \
|
|
(ULONG)RtlCompareMemory(
|
|
ResourceInfo,
|
|
pVersionInfo,
|
|
InputCompareLength
|
|
);
|
|
|
|
}
|
|
else{
|
|
OutputCompareLength = 0;
|
|
}
|
|
|
|
if( InputCompareLength != OutputCompareLength){
|
|
// No match found...Need to continue thru till I find one or exhaust.
|
|
TotalGooLength -= pAppCompatEntry->dwEntryTotalSize;
|
|
(PUCHAR) pAppCompatEntry += pAppCompatEntry->dwEntryTotalSize;
|
|
iLoop++;
|
|
continue;
|
|
}
|
|
|
|
// We are a match !!
|
|
pStoredAppCompatEntry = pAppCompatEntry;
|
|
fMatchGot = TRUE;
|
|
// Since we are a match, we won't add the ApplicationGoo but we need to check the
|
|
// ApcompatFlag and the OSVersionInfo.
|
|
if( (!pAppCompatFlag) && (!pOsVersionInfo) )
|
|
break;
|
|
|
|
OffSet = sizeof(PRE_APP_COMPAT_INFO) + \
|
|
pStoredAppCompatEntry->dwResourceInfoSize;
|
|
if(pAppCompatFlag){
|
|
(PUCHAR)pExistingAppCompatFlag = (PUCHAR) ( pStoredAppCompatEntry) + OffSet;
|
|
InputCompareLength = sizeof(LARGE_INTEGER);
|
|
OutputCompareLength = \
|
|
(ULONG) RtlCompareMemory(
|
|
pAppCompatFlag,
|
|
pExistingAppCompatFlag,
|
|
InputCompareLength
|
|
);
|
|
if(OutputCompareLength == InputCompareLength)
|
|
fAppCompatMatch = TRUE;
|
|
}
|
|
|
|
|
|
if(pOsVersionInfo){
|
|
(PUCHAR)pExistingOsVersionInfo = (PUCHAR) (pStoredAppCompatEntry) + OffSet + \
|
|
sizeof(LARGE_INTEGER);
|
|
InputCompareLength = pStoredAppCompatEntry->dwEntryTotalSize - \
|
|
(sizeof(PRE_APP_COMPAT_INFO) + \
|
|
pStoredAppCompatEntry->dwResourceInfoSize +\
|
|
sizeof(LARGE_INTEGER)
|
|
);
|
|
if(InputCompareLength > TotalVersionInfoLength)
|
|
InputCompareLength = TotalVersionInfoLength;
|
|
|
|
OutputCompareLength = \
|
|
(ULONG) RtlCompareMemory(
|
|
pOsVersionInfo,
|
|
pExistingOsVersionInfo,
|
|
InputCompareLength
|
|
);
|
|
if(OutputCompareLength == InputCompareLength)
|
|
fOsVersionMatch = TRUE;
|
|
}
|
|
|
|
if( ( fOsVersionMatch == TRUE) &&
|
|
( fAppCompatMatch == TRUE) )
|
|
break;
|
|
else{ // one of these or both are different...
|
|
/*
|
|
The idea here is to replace that part of the AppCompatEntry, which is a
|
|
mis-match. We go ahead and prepare the pReplaceAppCompatEntry
|
|
*/
|
|
ReplaceCopyLength = sizeof(PRE_APP_COMPAT_INFO) + \
|
|
pStoredAppCompatEntry->dwResourceInfoSize + \
|
|
sizeof(LARGE_INTEGER) + \
|
|
TotalVersionInfoLength ;
|
|
pReplaceAppCompatEntry = GlobalAlloc(GMEM_FIXED, ReplaceCopyLength);
|
|
RtlCopyMemory((PUCHAR)pReplaceAppCompatEntry, (PUCHAR)pStoredAppCompatEntry, OffSet);
|
|
RtlCopyMemory((PUCHAR)(pReplaceAppCompatEntry) + OffSet,(PUCHAR)pAppCompatFlag,sizeof(LARGE_INTEGER) );
|
|
RtlCopyMemory((PUCHAR)(pReplaceAppCompatEntry)+(OffSet+sizeof(LARGE_INTEGER)),
|
|
(PUCHAR)pOsVersionInfo,TotalVersionInfoLength);
|
|
|
|
//Now prepare the GOO structure.
|
|
ReplaceGooLength = pExistingVersionInfo ->dwTotalGooSize - \
|
|
pStoredAppCompatEntry->dwEntryTotalSize + \
|
|
ReplaceCopyLength;
|
|
pReplaceAppCompatGoo = GlobalAlloc(GMEM_FIXED, ReplaceGooLength);
|
|
pReplaceAppCompatGoo->dwTotalGooSize = ReplaceGooLength;
|
|
|
|
pAppCompatEntry = pExistingVersionInfo->AppCompatEntry;
|
|
pDestAppCompatEntry = ((PAPP_COMPAT_GOO)pReplaceAppCompatGoo)->AppCompatEntry;
|
|
|
|
ReplaceGooLength -= sizeof(pExistingVersionInfo->dwTotalGooSize);
|
|
while(ReplaceGooLength){
|
|
CopyLength = pAppCompatEntry->dwEntryTotalSize;
|
|
if(pAppCompatEntry != pStoredAppCompatEntry){
|
|
RtlCopyMemory(pDestAppCompatEntry,pAppCompatEntry ,CopyLength);
|
|
(PUCHAR)pDestAppCompatEntry += CopyLength;
|
|
}
|
|
else{
|
|
RtlCopyMemory(pDestAppCompatEntry,pReplaceAppCompatEntry,ReplaceCopyLength);
|
|
pDestAppCompatEntry->dwEntryTotalSize = ReplaceCopyLength;
|
|
(PUCHAR)pDestAppCompatEntry += ReplaceCopyLength;
|
|
(PUCHAR)pAppCompatEntry += pAppCompatEntry->dwEntryTotalSize;
|
|
ReplaceGooLength -= ReplaceCopyLength;
|
|
continue;
|
|
}
|
|
|
|
(PUCHAR)pAppCompatEntry += CopyLength;
|
|
ReplaceGooLength -= CopyLength;
|
|
} // End while
|
|
// Delete the key from the registry and add back the updated one.
|
|
|
|
GetFileTitle(pszPath,szTitle,MAX_PATH);
|
|
if(CheckExtension(szTitle) == NULL)
|
|
lstrcat(szTitle,TEXT(".exe"));
|
|
DeleteRegistryValueGoo(szTitle);
|
|
SetRegistryValGoo(szTitle,
|
|
TEXT("ApplicationGoo"),
|
|
(PUCHAR)pReplaceAppCompatGoo,
|
|
REG_BINARY,
|
|
pReplaceAppCompatGoo->dwTotalGooSize
|
|
);
|
|
|
|
GlobalFree(pReplaceAppCompatEntry);
|
|
GlobalFree(pReplaceAppCompatGoo);
|
|
} // Else..
|
|
|
|
break;
|
|
} // End while (TotalGooLength )
|
|
|
|
|
|
if(FALSE == fMatchGot){
|
|
// No match available for this version.
|
|
fNeedAppend = TRUE;
|
|
// Reset the iteration count.
|
|
iLoop = 0;
|
|
}
|
|
|
|
if(g_fNotPermanent){
|
|
// The user has chosen not to make the registry settings permanent and we have the
|
|
// "Append" flag set indicating that there were entries appended to the ApplicationGoo.
|
|
// We need to remove the correct entry for this executable.
|
|
|
|
// The idea here is to copy the whole of "ApplicationGoo" to a global buffer leaving just
|
|
// the one that needs to be deleted. Our job is made easier as we have the stored AppCompat
|
|
// entry. We just need to go till there and copy the rest on to the global buffer.
|
|
|
|
if(pStoredAppCompatEntry){
|
|
pAppCompatEntry = pExistingVersionInfo->AppCompatEntry;
|
|
TotalGooLength = pExistingVersionInfo->dwTotalGooSize;
|
|
g_lpPrevRegSettings = (PAPP_COMPAT_GOO)GlobalAlloc(GMEM_FIXED, TotalGooLength );
|
|
((PAPP_COMPAT_GOO)g_lpPrevRegSettings)->dwTotalGooSize = pExistingVersionInfo->dwTotalGooSize -
|
|
pStoredAppCompatEntry->dwEntryTotalSize ;
|
|
pDestAppCompatEntry = ((PAPP_COMPAT_GOO)g_lpPrevRegSettings)->AppCompatEntry;
|
|
TotalGooLength -= sizeof(pExistingVersionInfo->dwTotalGooSize);
|
|
while(TotalGooLength){
|
|
CopyLength = pAppCompatEntry->dwEntryTotalSize;
|
|
if(pAppCompatEntry != pStoredAppCompatEntry){
|
|
RtlCopyMemory(pDestAppCompatEntry,pAppCompatEntry ,CopyLength);
|
|
(PUCHAR)pDestAppCompatEntry += CopyLength;
|
|
g_GooAppendFlag = TRUE;
|
|
}
|
|
|
|
(PUCHAR)pAppCompatEntry += CopyLength;
|
|
TotalGooLength -= CopyLength;
|
|
} // End while.
|
|
}
|
|
else{ // We do not have a stored AppCompatEntry. This means our target is to remove the
|
|
// the first entry and leave the rest intact. i.e copy the rest onto the global buffer
|
|
// for it to be copied.
|
|
TotalGooLength = pExistingVersionInfo->dwTotalGooSize;
|
|
g_lpPrevRegSettings = (PAPP_COMPAT_GOO)GlobalAlloc(GMEM_FIXED, TotalGooLength );
|
|
RtlCopyMemory(g_lpPrevRegSettings,pExistingVersionInfo, TotalGooLength);
|
|
g_GooAppendFlag = TRUE;
|
|
}
|
|
}
|
|
|
|
return fNeedAppend;
|
|
}
|
|
|
|
|
|
|
|
int MakeAppCompatGoo(TCHAR* TmpBuffer,LARGE_INTEGER* pAppCompatFlag, UINT uOsVer)
|
|
{
|
|
BOOLEAN fImageHasVersionInfo = FALSE;
|
|
BOOLEAN fOsVersionLie = FALSE;
|
|
BOOLEAN fEntryPresent = FALSE;
|
|
TCHAR Buffer[MAX_PATH];
|
|
TCHAR StringBuffer[MAX_PATH];
|
|
TCHAR RegPath[MAX_PATH];
|
|
TCHAR InChar;
|
|
LONG status;
|
|
HKEY hKey;
|
|
PTCHAR pBuf;
|
|
PTCHAR pAppGooBuf;
|
|
PUCHAR pData;
|
|
PTCHAR OutBuffer;
|
|
PWCHAR uniBuffer;
|
|
DWORD VersionInfoSize;
|
|
DWORD dwHandle;
|
|
DWORD dwBytesWritten;
|
|
DWORD dwType;
|
|
DWORD dwSize;
|
|
ULONG i, j;
|
|
ULONG EXELength;
|
|
ULONG AppCompatHigh;
|
|
ULONG AppCompatLow;
|
|
ULONG TotalGooSize;
|
|
ULONG TotalVersionInfoLength=0;
|
|
ULONG OutBufferSize;
|
|
PVOID lpData;
|
|
PVOID ResourceInfo;
|
|
PVOID VersionInfo;
|
|
PAPP_COMPAT_GOO AppCompatGoo;
|
|
PAPP_VARIABLE_INFO VariableInfo=NULL;
|
|
PAPP_VARIABLE_INFO AppVariableInfo=NULL;
|
|
EFFICIENTOSVERSIONINFOEXW OSVersionInfo, *pOsVersionInfo;
|
|
|
|
// Remove the trailing and leading " " if PRESENT.
|
|
if(*TmpBuffer == TEXT('\"') ){
|
|
lstrcpy(Buffer, TmpBuffer+1);
|
|
*(Buffer + (lstrlen(Buffer) - 1) )= TEXT('\0');
|
|
}
|
|
else
|
|
lstrcpy(Buffer, TmpBuffer);
|
|
|
|
// Quick check to see if its got any version info in its header
|
|
VersionInfoSize = GetFileVersionInfoSize(&Buffer[0], &dwHandle);
|
|
if (VersionInfoSize) {
|
|
// It does, so alloc space for it to pull it in below
|
|
VersionInfo = LocalAlloc(GMEM_FIXED, VersionInfoSize);
|
|
if (VersionInfo) {
|
|
// Get the version info
|
|
if (GetFileVersionInfo(&Buffer[0], dwHandle, VersionInfoSize, VersionInfo)) {
|
|
// Set global flag to be inspected later
|
|
fImageHasVersionInfo = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Enter the app compat flags (decimal) - its defined as a LARGE_INTEGER
|
|
AppCompatHigh = 0x0;
|
|
AppCompatLow = 0x0;
|
|
AppCompatLow = pAppCompatFlag->LowPart;
|
|
AppCompatHigh = pAppCompatFlag->HighPart;
|
|
|
|
|
|
// Determine goo size, start with main goo
|
|
TotalGooSize = sizeof(APP_COMPAT_GOO);
|
|
|
|
|
|
|
|
// Add sizeof compatibility flags (large integer)
|
|
TotalGooSize += sizeof(LARGE_INTEGER);
|
|
// if we actually got version information add the length of that. We take the minimum
|
|
// of whatever the EXE has or 0x200 bytes to try and identify the app. I've found that
|
|
// anything less than 0x200 bytes doesn't supply enough info to be useful.
|
|
if (fImageHasVersionInfo) {
|
|
VersionInfoSize = min(VersionInfoSize, MIN_VERSION_RESOURCE);
|
|
TotalGooSize += VersionInfoSize;
|
|
}
|
|
|
|
// See if they requested version lying, if so we got a bunch more horseshit todo
|
|
if (AppCompatLow & KACF_VERSIONLIE) {
|
|
fOsVersionLie = TRUE;
|
|
|
|
OSVersionInfo.dwMajorVersion = uVersionInfo[uOsVer][0];
|
|
OSVersionInfo.dwMinorVersion = uVersionInfo[uOsVer][1];
|
|
OSVersionInfo.dwBuildNumber = uVersionInfo[uOsVer][2];
|
|
OSVersionInfo.dwPlatformId = uVersionInfo[uOsVer][3];
|
|
OSVersionInfo.wServicePackMajor = (WORD)uVersionInfo[uOsVer][4];
|
|
OSVersionInfo.wServicePackMinor = (WORD)uVersionInfo[uOsVer][5];
|
|
OSVersionInfo.wSuiteMask = (WORD)uVersionInfo[uOsVer][6];
|
|
OSVersionInfo.wProductType = (BYTE)uVersionInfo[uOsVer][7];
|
|
lstrcpy( (TCHAR*) OSVersionInfo.szCSDVersion, pszVersionInfo[uOsVer]);
|
|
|
|
|
|
// Start with the length of the full struct
|
|
TotalVersionInfoLength = sizeof(EFFICIENTOSVERSIONINFOEXW);
|
|
// subtract the size of the szCSDVersion field
|
|
TotalVersionInfoLength -= sizeof(OSVersionInfo.szCSDVersion);
|
|
|
|
// add the strlen amount plus 1 for the NULL wchar
|
|
TotalVersionInfoLength += lstrlen((TCHAR*)OSVersionInfo.szCSDVersion )*sizeof(WCHAR)+sizeof(WCHAR);
|
|
|
|
// Add the size of the variable length structure header (since VerInfo is var length)
|
|
TotalVersionInfoLength += sizeof(APP_VARIABLE_INFO);
|
|
// Add the total version info length to the goo size
|
|
TotalGooSize += TotalVersionInfoLength;
|
|
// Allocate space for the variable length version info
|
|
AppVariableInfo = (PAPP_VARIABLE_INFO) LocalAlloc(GMEM_FIXED, sizeof(APP_VARIABLE_INFO) + TotalVersionInfoLength);
|
|
if (!AppVariableInfo) {
|
|
return -1;
|
|
}
|
|
// fill in the pertinent data in the variable length info header
|
|
AppVariableInfo->dwVariableInfoSize = sizeof(APP_VARIABLE_INFO) + TotalVersionInfoLength;
|
|
AppVariableInfo->dwVariableType = AVT_OSVERSIONINFO;
|
|
// Do a pointer +1 operation here to get past the header to the actual data
|
|
VariableInfo = AppVariableInfo + 1;
|
|
// Copy the actual data in
|
|
memcpy(VariableInfo, &OSVersionInfo, TotalVersionInfoLength);
|
|
|
|
}
|
|
|
|
//
|
|
// See if an entry already exists in the registry. If so, we'll have to glom
|
|
// this entry into the other already existing one.
|
|
//
|
|
// Get the registry path all figured out
|
|
memset(&RegPath[0], 0, sizeof(RegPath));
|
|
lstrcat(&RegPath[0], IMAGE_EXEC_OPTIONS);
|
|
EXELength = lstrlen(&Buffer[0]);
|
|
pBuf = &Buffer[0];
|
|
pBuf += EXELength;
|
|
// work backward in the path til we find the the last backslash
|
|
while ((*pBuf != '\\') && (pBuf != &Buffer[0])) {
|
|
pBuf--;
|
|
}
|
|
if (*pBuf == '\\') {
|
|
pBuf++;
|
|
}
|
|
|
|
if(CheckExtension(pBuf) == NULL)
|
|
lstrcat(pBuf,TEXT(".exe"));
|
|
|
|
// cat the image.exe name to the end of the registry path
|
|
lstrcat(&RegPath[0], pBuf);
|
|
// try to open this key
|
|
status = RegOpenKey(HKEY_LOCAL_MACHINE, &RegPath[0], &hKey);
|
|
if (status == ERROR_SUCCESS) {
|
|
dwSize = 1;
|
|
// do a query once with small size to figure out how big the binary entry is
|
|
status = RegQueryValueEx(hKey, TEXT("ApplicationGoo"), NULL, &dwType, NULL, &dwSize);
|
|
if( status == ERROR_SUCCESS){
|
|
//
|
|
// There's an entry already there. Take the size of this Goo entry and add it
|
|
// to the TotalGooSize LESS the size of the first dword in the APP_COMPAT_GOO
|
|
// struct (as there already was one there).
|
|
//
|
|
|
|
// Added here after checkin
|
|
if(dwSize > 1){
|
|
lpData = LocalAlloc(GMEM_FIXED, dwSize);
|
|
if(lpData){
|
|
status = RegQueryValueEx(hKey, TEXT("ApplicationGoo"), NULL, &dwType, (PUCHAR) lpData, &dwSize);
|
|
// if(VersionInfo) ...Remove this as it is not necessary.
|
|
// if(fOsVersionLie)
|
|
// pOsVersionInfo = VariableInfo;
|
|
|
|
fEntryPresent = CheckGooEntry( VersionInfo,
|
|
(PAPP_COMPAT_GOO)lpData,
|
|
fImageHasVersionInfo,
|
|
VersionInfoSize,
|
|
dwSize,
|
|
pAppCompatFlag,
|
|
AppVariableInfo,
|
|
TotalVersionInfoLength,
|
|
Buffer
|
|
);
|
|
}
|
|
}
|
|
|
|
// End add
|
|
|
|
|
|
if(fEntryPresent)
|
|
TotalGooSize += dwSize - sizeof(AppCompatGoo->dwTotalGooSize);
|
|
|
|
else{ // Nothing to append....return as it is the same.
|
|
if(fImageHasVersionInfo)
|
|
LocalFree(VersionInfo);
|
|
if(fOsVersionLie)
|
|
LocalFree(AppVariableInfo);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
|
|
// Allocate the memory for the entire app compat goo
|
|
AppCompatGoo = (PAPP_COMPAT_GOO) LocalAlloc(GMEM_FIXED, TotalGooSize);
|
|
if (!AppCompatGoo) {
|
|
return -1;
|
|
}
|
|
|
|
// fill in the total size
|
|
AppCompatGoo->dwTotalGooSize = TotalGooSize;
|
|
// if there was version info for this entry we need to fill that in now, else zero
|
|
if (fImageHasVersionInfo) {
|
|
AppCompatGoo->AppCompatEntry[0].dwResourceInfoSize = VersionInfoSize;
|
|
}
|
|
else {
|
|
AppCompatGoo->AppCompatEntry[0].dwResourceInfoSize = 0;
|
|
}
|
|
AppCompatGoo->AppCompatEntry[0].dwEntryTotalSize = \
|
|
sizeof(AppCompatGoo->AppCompatEntry[0].dwEntryTotalSize) +
|
|
sizeof(AppCompatGoo->AppCompatEntry[0].dwResourceInfoSize) +
|
|
TotalVersionInfoLength + // In case app needed VER lying
|
|
sizeof(LARGE_INTEGER); // For app compatibility flags
|
|
|
|
// Entry size is whatever it was plus any resource info we've got
|
|
AppCompatGoo->AppCompatEntry[0].dwEntryTotalSize += \
|
|
AppCompatGoo->AppCompatEntry[0].dwResourceInfoSize;
|
|
// do the pointer +1 thing so we can be pointing at the data area
|
|
ResourceInfo = AppCompatGoo->AppCompatEntry + 1;
|
|
// copy the data in
|
|
memcpy(ResourceInfo, VersionInfo, VersionInfoSize);
|
|
|
|
// filling in the app compat flags here
|
|
pData = (PUCHAR) ResourceInfo + AppCompatGoo->AppCompatEntry[0].dwResourceInfoSize;
|
|
memcpy(pData, &AppCompatLow, sizeof(AppCompatLow));
|
|
pData += sizeof(AppCompatLow);
|
|
memcpy(pData, &AppCompatHigh, sizeof(AppCompatHigh));
|
|
pData += sizeof(AppCompatHigh);
|
|
// if there was any version resource info, copy that in here too
|
|
if (AppVariableInfo) {
|
|
memcpy(pData, AppVariableInfo, TotalVersionInfoLength);
|
|
}
|
|
pData += TotalVersionInfoLength;
|
|
//
|
|
// If an already existing entry was there, we need to ask append what was there to the
|
|
// tail of the entry. (i.e. what's already there gets auto appended to the tail). If
|
|
// someone wants to write a 1-N positioning for entries within the Goo - they'll have to
|
|
// add that support here
|
|
//
|
|
if (fEntryPresent) {
|
|
// Start at offset + 4 cuz the previous Total Goo size must be skipped.
|
|
memcpy(pData, (PUCHAR) lpData+4, dwSize - sizeof(AppCompatGoo->dwTotalGooSize));
|
|
}
|
|
|
|
|
|
pData = (PUCHAR) AppCompatGoo;
|
|
SetRegistryValGoo(pBuf, TEXT("ApplicationGoo"),pData,REG_BINARY,AppCompatGoo->dwTotalGooSize);
|
|
|
|
|
|
if(fImageHasVersionInfo)
|
|
LocalFree(VersionInfo);
|
|
if(fOsVersionLie)
|
|
LocalFree(AppVariableInfo);
|
|
if(fEntryPresent)
|
|
LocalFree(lpData);
|
|
LocalFree(AppCompatGoo);
|
|
return 0;
|
|
}
|