able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/restools/mui/muibld/muibld.c

1272 lines
36 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <assert.h>
#include <io.h>
#include <md5.h>
#include "muibld.h"
typedef struct
{
BOOL bContainResource;
MD5_CTX ChecksumContext;
} CHECKSUM_ENUM_DATA;
void ExitFromOutOfMemory();
void DumpResourceDirectory
(
PIMAGE_RESOURCE_DIRECTORY resDir,
DWORD resourceBase,
DWORD level,
DWORD resourceType
);
int g_bVerbose = FALSE; // Global flag to contorl verbose output.
WORD wChecksumLangId;
// The predefined resource types
char *SzResourceTypes[] = {
"???_0", "CURSOR", "BITMAP", "ICON", "MENU", "DIALOG", "STRING", "FONTDIR",
"FONT", "ACCELERATORS", "RCDATA", "MESSAGETABLE", "GROUP_CURSOR",
"???_13", "GROUP_ICON", "???_15", "VERSION"
};
void PrintError()
{
LPTSTR lpMsgBuf;
if (FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(LPTSTR) &lpMsgBuf,
0,
NULL
))
{
printf("GetLastError():\n %s", lpMsgBuf);
LocalFree( lpMsgBuf );
}
return;
}
////////////////////////////////////////////////////////////////////////////////////
//
// ChecksumEnumNamesFunc
//
// The callback funciton for enumerating the resource names in the specified module and
// type.
// The side effect is that MD5 checksum context (contained in CHECKSUM_ENUM_DATA
// pointed by lParam) will be updated.
//
// Return:
// Always return TRUE so that we can finish all resource enumeration.
//
////////////////////////////////////////////////////////////////////////////////////
BOOL CALLBACK ChecksumEnumNamesFunc(HMODULE hModule, LPCTSTR lpType, LPTSTR lpName, LONG_PTR lParam){
HRSRC hRsrc;
HGLOBAL hRes;
const unsigned char* pv;
LONG ResSize=0L;
WORD IdFlag=0xFFFF;
DWORD dwHeaderSize=0L;
CHECKSUM_ENUM_DATA* pChecksumEnumData = (CHECKSUM_ENUM_DATA*)lParam;
if(!(hRsrc=FindResourceEx(hModule, lpType, lpName, wChecksumLangId ? wChecksumLangId : 0x409)))
{
//
// If US English resource is not found for the specified type and name, we
// will continue the resource enumeration.
//
return (TRUE);
}
pChecksumEnumData->bContainResource = TRUE;
if (!(ResSize=SizeofResource(hModule, hRsrc)))
{
printf("WARNING: Can not get resource size when generating resource checksum.\n");
return (TRUE);
}
if (!(hRes=LoadResource(hModule, hRsrc)))
{
printf("WARNING: Can not load resource when generating resource checksum.\n");
return (TRUE);
}
pv=(unsigned char*)LockResource(hRes);
//
// Update MD5 context using the binary data of this particular resource.
//
MD5Update(&(pChecksumEnumData->ChecksumContext), pv, ResSize);
return TRUE;
}
////////////////////////////////////////////////////////////////////////////////////
//
// ChecksumEnumTypesFunc
//
// The callback function for enumerating the resource types in the specified module.
// This function will call EnumResourceNames() to enumerate all resource names of
// the specified resource type.
//
// Return:
// TRUE if EnumResourceName() succeeds. Otherwise FALSE.
//
////////////////////////////////////////////////////////////////////////////////////
BOOL CALLBACK ChecksumEnumTypesFunc(HMODULE hModule, LPSTR lpType, LONG_PTR lParam)
{
CHECKSUM_ENUM_DATA* pChecksumEnumData = (CHECKSUM_ENUM_DATA*)lParam;
//
// Skip the version resource type, so that version is not included in the resource checksum.
//
if (lpType == RT_VERSION)
{
return (TRUE);
}
if(!EnumResourceNames(hModule, (LPCSTR)lpType, ChecksumEnumNamesFunc, (LONG_PTR)lParam))
{
return (FALSE);
}
return (TRUE);
}
////////////////////////////////////////////////////////////////////////////////////
//
// GenerateResourceChecksum
//
// Generate the resource checksum for the US English resource in the specified file.
//
// Parameters:
// pszSourceFileName The file used to generate resource checksum.
// pResourceChecksum Pointer to a 16 bytes (128 bits) buffer for storing
// the calcuated MD5 checksum.
// Return:
// TURE if resource checksum is generated from the given file. Otherwise FALSE.
//
// The following situation may return FALSE:
// * The specified file does not contain resource.
// * If the specified file contains resource, but the resource is not US English.
// * The specified file only contains US English version resource.
//
////////////////////////////////////////////////////////////////////////////////////
BOOL GenerateResourceChecksum(LPCSTR pszSourceFileName, unsigned char* pResourceChecksum)
{
HMODULE hModule;
ULONG i;
DWORD dwResultLen;
BOOL bRet = FALSE;
//
// The stucture to be passed into the resource enumeration functions.
//
CHECKSUM_ENUM_DATA checksumEnumData;
checksumEnumData.bContainResource = FALSE;
//
// Start MD5 checksum calculation by initializing MD5 context.
//
MD5Init(&(checksumEnumData.ChecksumContext));
if (g_bVerbose)
{
printf("Generate resource checksum for [%s]\n", pszSourceFileName);
}
if(!(hModule = LoadLibraryEx(pszSourceFileName, NULL, DONT_RESOLVE_DLL_REFERENCES|LOAD_LIBRARY_AS_DATAFILE)))
{
if (g_bVerbose)
{
printf("\nERROR: Error in opening resource checksum module [%s]\n", pszSourceFileName);
}
PrintError();
goto GR_EXIT;
}
if (g_bVerbose)
{
printf("\nLoad checksum file: %s\n", pszSourceFileName);
}
//
// we check language id of Version resource if it has wChecksumLangId when wChecksumLangId has value
//
if (wChecksumLangId && wChecksumLangId != 0x409)
{
if(!FindResourceEx(hModule, MAKEINTRESOURCE(16), MAKEINTRESOURCE(1), wChecksumLangId))
{ //
// It does not has specifed language id in version resource, we supposed that this binary does not
// have any language id specified at all, so we set it as 0 in order to use English instead.
//
wChecksumLangId = 0;
}
}
//
// Enumerate all resources in the specified module.
// During the enumeration, the MD5 context will be updated.
//
if (!EnumResourceTypes(hModule, ChecksumEnumTypesFunc, (LONG_PTR)&checksumEnumData))
{
if (g_bVerbose)
{
printf("\nWARNING: Unable to generate resource checksum from resource checksum module [%s]\n", pszSourceFileName);
}
goto GR_EXIT;
}
if (checksumEnumData.bContainResource)
{
//
// If the enumeration succeeds, and the specified file contains US English
// resource, get the MD5 checksum from the accumulated MD5 context.
//
MD5Final(&checksumEnumData.ChecksumContext);
memcpy(pResourceChecksum, checksumEnumData.ChecksumContext.digest, 16);
if (g_bVerbose)
{
printf("Generated checksum: [");
for (i = 0; i < MD5_CHECKSUM_SIZE; i++)
{
printf("%02x ", pResourceChecksum[i]);
}
printf("]\n");
}
bRet = TRUE;
}
GR_EXIT:
if (hModule)
{
FreeLibrary(hModule);
}
return (bRet);
}
int __cdecl main(int argc, char *argv[]){
struct CommandLineInfo Info;
HMODULE hModule=0;
char pszBuffer[400];
DWORD dwError;
DWORD dwOffset;
BOOL bEnumTypesReturn;
if(argc==1){
Usage();
return 0;
}
g_bVerbose=FALSE;
wChecksumLangId=0;
Info.pszIncResType=0;
Info.wLanguage=0;
Info.hFile=0;
Info.pszSource=0;
Info.pszTarget=0;
Info.bContainsOnlyVersion=TRUE;
Info.bContainsResources=FALSE;
Info.bLanguageFound=FALSE;
Info.bIncDependent=FALSE;
Info.bIncludeFlag=FALSE;
Info.pszChecksumFile=NULL;
Info.bIsResChecksumGenerated = FALSE;
if(ParseCommandLine(argc, argv, &Info)==FALSE){
//...If help was the only command line argument, exit
if(strcmp(argv[1], "-h")==0 && argc==2)
return 0;
dwError=ERROR_TOO_FEW_ARGUMENTS;
dwOffset=0;
goto Error_Exit;
}
//...Open resource module
if(Info.pszSource){
if(!(hModule = LoadLibraryEx (Info.pszSource, NULL, DONT_RESOLVE_DLL_REFERENCES|LOAD_LIBRARY_AS_DATAFILE)))
{
PrintError();
if (g_bVerbose)
{
printf("\nERROR: Error in opening source module [%s]\n", Info.pszSource);
}
dwError=GetLastError();
dwOffset=ERROR_OFFSET;
goto Error_Exit;
}
}
else {
Usage();
dwError=ERROR_NO_SOURCE;
dwOffset=0;
goto Error_Exit;
}
if (Info.pszChecksumFile)
{
if (GenerateResourceChecksum(Info.pszChecksumFile, Info.pResourceChecksum))
{
Info.bIsResChecksumGenerated = TRUE;
}
}
//...Create target file
if(Info.pszTarget){
if((Info.hFile=CreateFile(Info.pszTarget, GENERIC_WRITE | GENERIC_READ, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE)
{
if (g_bVerbose)
{
printf("\nERROR: Error in creating target module [%s]\n", Info.pszSource);
}
dwError=GetLastError();
dwOffset=ERROR_OFFSET;
goto Error_Exit;
}
}
else{
if (g_bVerbose)
{
printf("\nERROR: There is no target file name.");
}
Usage();
dwError=ERROR_NO_TARGET;
dwOffset=0;
goto Error_Exit;
}
if(Info.wLanguage==0){
if (g_bVerbose)
{
printf("\nERROR: Can not find specified language name in the source module.");
}
Usage();
dwError=ERROR_NO_LANGUAGE_SPECIFIED;
dwOffset=0;
goto Error_Exit;
}
bInsertHeader(Info.hFile);
bEnumTypesReturn=EnumResourceTypes(hModule, EnumTypesFunc, (LONG_PTR)&Info);
//...Check for muibld errors
if(!Info.bContainsResources){
if (g_bVerbose)
{
printf("\nERROR: There is no resource in the source module.");
}
dwError=ERROR_NO_RESOURCES;
dwOffset=0;
goto Error_Exit;
}
if(!Info.bLanguageFound){
if (g_bVerbose)
{
printf("\nERROR: There is no specified language in the source module.");
}
dwError=ERROR_LANGUAGE_NOT_IN_SOURCE;
dwOffset=0;
goto Error_Exit;
}
if(Info.bContainsOnlyVersion){
if (g_bVerbose)
{
printf("\nERROR: The source module only contains version information.");
}
dwError=ERROR_ONLY_VERSION_STAMP;
dwOffset=0;
goto Error_Exit;
}
//...Check for system errors in EnumResourceTypes
if(bEnumTypesReturn);
else{
dwError=GetLastError();
dwOffset=ERROR_OFFSET;
goto Error_Exit;
}
//...Check to see if extra resources were included
if(Info.bIncDependent){
CleanUp(&Info, hModule, FALSE);
return DEPENDENT_RESOURCE_REMOVED;
}
CleanUp(&Info, hModule, FALSE);
if (g_bVerbose)
{
printf("Resource file [%s] has been generated successfully.\n", Info.pszTarget);
}
return 0;
Error_Exit:
CleanUp(&Info, hModule, TRUE);
if(dwOffset==ERROR_OFFSET){
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError, 0, (LPTSTR)&pszBuffer, 399, NULL);
fprintf(stderr, "\n%s\n", pszBuffer );
}
return dwError+dwOffset;
}
BOOL ParseCommandLine(int argc, char **argv, pCommandLineInfo pInfo){
int iCount=1, chOpt=0, iLast=argc;
int i;
int iNumInc;
BOOL bInc1=FALSE, bInc3=FALSE, bInc12=FALSE, bInc14=FALSE;
iLast=argc;
//...Must have at least: muibld -l langid source
if(argc>3){
//...Determine the target and source files.
if(CreateFile(argv[argc-2], 0, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)!=INVALID_HANDLE_VALUE){
pInfo->pszSource=LocalAlloc(0, (strlen(argv[argc-2])+1) * sizeof(char));
if (pInfo->pszSource == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszSource, argv[argc-2]);
pInfo->pszTarget=LocalAlloc(0, (strlen(argv[argc-1])+1) * sizeof(char));
if (pInfo->pszTarget == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszTarget, argv[argc-1]);
iLast=argc-2;
}
else {
pInfo->pszSource=LocalAlloc(0, (strlen(argv[argc-1])+1) * sizeof(char));
if (pInfo->pszSource == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszSource, argv[argc-1]);
pInfo->pszTarget=LocalAlloc(0, (strlen(argv[argc-1]) + strlen(ADDED_EXT) + 1) * sizeof(char));
if (pInfo->pszTarget == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszTarget, strcat(argv[argc-1], ADDED_EXT));
iLast=argc-1;
}
}
//...Read in flags and arguments
while ( (iCount < iLast) && (*argv[iCount] == '-' || *argv[iCount] == '/')){
switch( ( chOpt = *CharLowerA( &argv[iCount][1]))) {
case '?':
case 'h':
printf("\n\n");
printf("MUIBLD [-h|?] [-v] [-c checksum_file] -l langid [-i resource_type] source_filename\n");
printf(" [target_filename]\n\n");
printf("-h(elp) or -?: Show help screen.\n\n");
printf("-i(nclude) Use to include certain resource types,\n");
printf("resource_type: e.g. -i 2 to include bitmaps.\n");
printf(" Multiple inclusion is possible. If this\n");
printf(" flag is not used, all types are included\n");
printf(" Standard resource types must be specified\n");
printf(" by number. See below for list.\n");
printf(" Types 1 and 12 are always included in pairs,\n");
printf(" even if only one is specified. Types 3 and 14\n");
printf(" are always included in pairs, too.\n\n");
printf("-v(erbose): Display source filename and target filename.\n\n");
printf("-l(anguage) langid: Extract only resource in this language.\n");
printf(" The language resource must be specified. The value is in decimal.\n\n");
printf("source_filename: The localized source file (no wildcard support)\n\n");
printf("target_filename: Optional. If no target_filename is specified,\n");
printf(" a second extension.RES is added to the\n");
printf(" source_filename.\n\n");
printf("Standard Resource Types: CURSOR(1) BITMAP(2) ICON(3) MENU(4) DIALOG(5)\n");
printf("STRING(6) FONTDIR(7) FONT(8) ACCELERATORS(9) RCDATA(10) MESSAGETABLE(11)\n");
printf("GROUP_CURSOR(12) GROUP_ICON(14) VERSION(16)\n");
iCount++;
break;
case 'v':
g_bVerbose=TRUE;
iCount++;
break;
case 'c':
iCount++;
pInfo->pszChecksumFile=LocalAlloc(0, (strlen(argv[iCount])+1) * sizeof(char));
if (pInfo->pszChecksumFile == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszChecksumFile, argv[iCount]);
iCount++;
break;
case 'b':
iCount++;
wChecksumLangId = (WORD)strtoul(argv[iCount], NULL, 0);
iCount++;
break;
case 'i':
if(argc<4)
return FALSE;
pInfo->bIncludeFlag=TRUE;
iNumInc=++iCount;
//...Allocate memory for and copy included types
while (argv[iNumInc][0]!='-' && iNumInc<iLast){
iNumInc++;
}
iNumInc-=iCount;
//... Allocate enough memory for specified included resources
// and unspecified resources dependent on them
pInfo->pszIncResType=LocalAlloc(0 ,(iNumInc+3)*sizeof(char *));
if (pInfo->pszIncResType == NULL)
{
ExitFromOutOfMemory();
}
i=0;
while(i<iNumInc){
pInfo->pszIncResType[i]=LocalAlloc(0, (strlen(argv[iCount])+1) * sizeof(char));
if (pInfo->pszIncResType[i] == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszIncResType[i], argv[iCount]);
switch(atoi(argv[iCount])){
case 1:
bInc1=TRUE;
break;
case 3:
bInc3=TRUE;
break;
case 12:
bInc12=TRUE;
break;
case 14:
bInc14=TRUE;
break;
default:
break;
}
i++;
iCount++;
}
//...If 1 or 12 is included, make sure both are included
if(bInc1 ^ bInc12){
pInfo->bIncDependent=TRUE;
if(bInc1){
pInfo->pszIncResType[i]=LocalAlloc(0, 3 * sizeof(char));
if (pInfo->pszIncResType[i] == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszIncResType[i], "12");
i++;
}
else{
pInfo->pszIncResType[i]=LocalAlloc(0, 2 * sizeof(char));
if (pInfo->pszIncResType[i] == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszIncResType[i], "1");
i++;
}
}
//..If 3 or 14 is included, make sure both are included
if(bInc3 ^ bInc14){
pInfo->bIncDependent=TRUE;
if(bInc3){
pInfo->pszIncResType[i]=LocalAlloc(0, 3 * sizeof(char));
if (pInfo->pszIncResType[i] == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszIncResType[i], "14");
i++;
}
else{
pInfo->pszIncResType[i]=LocalAlloc(0, 2 * sizeof(char));
if (pInfo->pszIncResType[i] == NULL)
{
ExitFromOutOfMemory();
}
strcpy(pInfo->pszIncResType[i], "3");
i++;
}
}
while(i<iNumInc + 3){
pInfo->pszIncResType[i++]=NULL;
}
break;
case 'l':
if(argc<4)
return FALSE;
iCount++;
pInfo->wLanguage=(WORD)strtol(argv[iCount], NULL, 0);
iCount++;
break;
}
}
if(argc<4)
return FALSE;
else
return TRUE;
}
BOOL CALLBACK EnumTypesFunc(HMODULE hModule, LPTSTR lpType, LONG_PTR lParam){
pCommandLineInfo pInfo;
pInfo=(pCommandLineInfo)lParam;
if(!pInfo->bIncludeFlag || bTypeIncluded((char *)lpType, pInfo->pszIncResType)) {
pInfo->bContainsResources=TRUE;
//...If the type is a string or a number other than 16...
if( (PtrToUlong(lpType) & 0xFFFF0000) || ((WORD)PtrToUlong(lpType)!=16) ){
pInfo->bContainsOnlyVersion=FALSE;
}
if(EnumResourceNames(hModule, (LPCTSTR)lpType, EnumNamesFunc, (LONG_PTR)pInfo));
else {
return FALSE;
}
}
return TRUE;
}
// This is a Var struct within VarFileInfo for storing checksum for the source file.
// The current size for this structure is 56 bytes.
typedef struct VAR_SRC_CHECKSUM
{
WORD wLength;
WORD wValueLength;
WORD wType;
WCHAR szResourceChecksum[17]; // For storing "ResourceChecksum" null-terminated string in Unicode.
DWORD dwChecksum[4]; // 128 bit checksum = 16 bytes = 4 DWORD.
} VarResourceChecksum;
// This is a Var struct within VarFileInfo for stroing the resource types used in this file.
struct VarResourceTypes
{
WORD wLength;
WORD wValueLength;
WORD wType;
WCHAR szResourceType[13];
//BYTE padding[0]; // WORD * 3 + UnicodeChar*13 = 32 bytes. So we need 0 bytes padding for DWORD alignment.
DWORD* dwTypes; // 128 bit checksum = 16 bytes = 4 DWORD.
};
BOOL WriteResHeader(
HANDLE hFile, LONG ResSize, LPCSTR lpType, LPCSTR lpName, WORD wLanguage, DWORD* pdwBytesWritten, DWORD* pdwHeaderSize)
{
DWORD iPadding;
WORD IdFlag=0xFFFF;
unsigned i;
LONG dwOffset;
//...write the resource's size.
PutDWord(hFile, ResSize, pdwBytesWritten, pdwHeaderSize);
//...Put in bogus header size
PutDWord(hFile, 0, pdwBytesWritten, pdwHeaderSize);
//...Write Resource Type
if(PtrToUlong(lpType) & 0xFFFF0000)
{
PutString(hFile, lpType, pdwBytesWritten, pdwHeaderSize);
}
else
{
PutWord(hFile, IdFlag, pdwBytesWritten, pdwHeaderSize);
PutWord(hFile, (USHORT)lpType, pdwBytesWritten, pdwHeaderSize);
}
//...Write Resource Name
if(PtrToUlong(lpName) & 0xFFFF0000){
PutString(hFile, lpName, pdwBytesWritten, pdwHeaderSize);
}
else{
PutWord(hFile, IdFlag, pdwBytesWritten, pdwHeaderSize);
PutWord(hFile, (USHORT)lpName, pdwBytesWritten, pdwHeaderSize);
}
//...Make sure Type and Name are DWORD-aligned
iPadding=(*pdwHeaderSize)%(sizeof(DWORD));
if(iPadding){
for(i=0; i<(sizeof(DWORD)-iPadding); i++){
PutByte (hFile, 0, pdwBytesWritten, pdwHeaderSize);
}
}
//...More Win32 header stuff
PutDWord(hFile, 0, pdwBytesWritten, pdwHeaderSize);
PutWord(hFile, 0x1030, pdwBytesWritten, pdwHeaderSize);
//...Write Language
PutWord(hFile, wLanguage, pdwBytesWritten, pdwHeaderSize);
//...More Win32 header stuff
PutDWord(hFile, 0, pdwBytesWritten, pdwHeaderSize); //... Version
PutDWord(hFile, 0, pdwBytesWritten, pdwHeaderSize); //... Characteristics
dwOffset=(*pdwHeaderSize)-4;
//...Set file pointer to where the header size is
if(SetFilePointer(hFile, -dwOffset, NULL, FILE_CURRENT));
else{
return FALSE;
}
PutDWord(hFile, (*pdwHeaderSize), pdwBytesWritten, NULL);
//...Set file pointer back to the end of the header
if(SetFilePointer(hFile, dwOffset-4, NULL, FILE_CURRENT));
else {
return FALSE;
}
return (TRUE);
}
BOOL WriteResource(HANDLE hFile, HMODULE hModule, WORD wLanguage, LPCSTR lpName, LPCSTR lpType, HRSRC hRsrc)
{
HGLOBAL hRes;
PVOID pv;
LONG ResSize=0L;
DWORD iPadding;
unsigned i;
DWORD dwBytesWritten;
DWORD dwHeaderSize=0L;
// Handle other types other than VS_VERSION_INFO
//...write the resource header
if(!(ResSize=SizeofResource(hModule, hRsrc)))
{
return FALSE;
}
//
// Generate an item in the RES format (*.res) file.
//
//
// First, we generated header for this resource.
//
if (!WriteResHeader(hFile, ResSize, lpType, lpName, wLanguage, &dwBytesWritten, &dwHeaderSize))
{
return (FALSE);
}
//Second, we copy resource data to the .res file
if (!(hRes=LoadResource(hModule, hRsrc)))
{
return FALSE;
}
if(!(pv=LockResource(hRes)))
{
return FALSE;
}
if (!WriteFile(hFile, pv, ResSize, &dwBytesWritten, NULL))
{
return FALSE;
}
//...Make sure resource is DWORD aligned
iPadding=dwBytesWritten%(sizeof(DWORD));
if(iPadding){
for(i=0; i<(sizeof(DWORD)-iPadding); i++){
PutByte (hFile, 0, &dwBytesWritten, NULL);
}
}
return TRUE;
}
LPBYTE UpdateAddr(LPBYTE pAddr, WORD size, WORD* len)
{
*len += size;
return (pAddr + size);
}
LPBYTE AddPadding(LPBYTE pAddr, WORD* padding, WORD* len)
{
if ((*padding = *len % 4) != 0)
{
*padding = (4 - *padding);
*len += *padding;
return (pAddr + *padding);
}
return (pAddr);
}
BOOL WriteVersionResource(
HANDLE hFile, HMODULE hModule, WORD wLanguage, LPCSTR lpName, LPCSTR lpType, HRSRC hRsrc, unsigned char* pbChecksum)
{
LONG ResSize=0L, OldResSize=0L;
DWORD dwBytesWritten;
DWORD dwHeaderSize=0L;
WORD IdFlag=0xFFFF;
BYTE* newVersionData;
BYTE* pAddr;
VarResourceChecksum varResourceChecksum;
PVOID pv = NULL;
HGLOBAL hRes;
WORD len = 0;
WORD wLength;
WORD wValueLength;
WORD wType;
LPWSTR szKey;
WORD wPadding1Count;
LPBYTE pValue;
WORD wPadding2Count;
int wTotalLen;
BOOL isVS_VERSIONINFO = TRUE;
BOOL isVarFileInfo = FALSE;
BOOL isStringFileInfo = FALSE;
BOOL bRet = FALSE;
//
// Copy resource data from the .res file
//
if (hRes=LoadResource(hModule, hRsrc))
{
pv=LockResource(hRes);
}
if (pv)
{
//
// The first WORD is the size of the VERSIONINFO resource.
//
OldResSize = *((WORD*)pv);
ResSize = OldResSize + sizeof(VarResourceChecksum);
//
// Generate an item in the RES format (*.res) file.
//
//
// First, we generated header for this resource in the RES file.
//
if (WriteResHeader(hFile, ResSize, lpType, lpName, wLanguage, &dwBytesWritten, &dwHeaderSize) &&
(newVersionData = (BYTE*)LocalAlloc(0, ResSize)))
{
bRet = TRUE;
memcpy(newVersionData, pv, OldResSize);
// Add the length of new VarResourceChecksum structure to VS_VERSIONINFO.wLength.
pAddr = newVersionData;
wTotalLen = *((WORD*)pAddr);
while (wTotalLen > 0)
{
len = 0;
wPadding1Count = 0;
wPadding2Count = 0;
// wLength
wLength = *((WORD*)pAddr);
pAddr = UpdateAddr(pAddr, sizeof(WORD), &len);
// wValueLength
wValueLength = *((WORD*)pAddr);
pAddr = UpdateAddr(pAddr, sizeof(WORD), &len);
// wType
wType = *((WORD*)pAddr);
pAddr = UpdateAddr(pAddr, sizeof(WORD), &len);
// szKey
szKey = (LPWSTR)pAddr;
pAddr = UpdateAddr(pAddr, (WORD)((wcslen((WCHAR*)pAddr) + 1) * sizeof(WCHAR)), &len);
// Padding 1
pAddr = AddPadding(pAddr, &wPadding1Count, &len);
// Value
pValue = pAddr;
if (wValueLength > 0)
{
if (wType==1)
{
// In the case of String, the wValueLength is in WORD (not in BYTE).
pAddr = UpdateAddr(pAddr, (WORD)(wValueLength * sizeof(WCHAR)), &len);
// Padding 2
pAddr = AddPadding(pAddr, &wPadding2Count, &len);
} else
{
pAddr = UpdateAddr(pAddr, wValueLength, &len);
if (isStringFileInfo)
{
//
// Generally, padding is not necessary in binary data.
// However, in some rare cases, people use binary data in the StringFileInfo (
// which is not really appropriate),
// So we need to add proper padding here to get around this.
//
// Padding 2
pAddr = AddPadding(pAddr, &wPadding2Count, &len);
}
}
}
if (isVS_VERSIONINFO)
{
//
// This is VS_VERSION_INFO.
//
// VS_VERSIONINFO can have padding 2.
isVS_VERSIONINFO = FALSE;
// Padding 2
pAddr = AddPadding(pAddr, &wPadding2Count, &len);
//
// Add the new VarResourceChecksum structure.
//
wLength += sizeof(VarResourceChecksum);
}
if (wcscmp(szKey, L"StringFileInfo") == 0)
{
isStringFileInfo = TRUE;
}
if (wcscmp(szKey, L"VarFileInfo") == 0)
{
isStringFileInfo = FALSE;
isVarFileInfo = TRUE;
wLength += sizeof(VarResourceChecksum);
}
PutWord(hFile, wLength, &dwBytesWritten, NULL);
PutWord(hFile, wValueLength, &dwBytesWritten, NULL);
PutWord(hFile, wType, &dwBytesWritten, NULL);
PutStringW(hFile, szKey, &dwBytesWritten, NULL);
PutPadding(hFile, wPadding1Count, &dwBytesWritten, NULL);
WriteFile(hFile, pValue, wValueLength * (wType == 0 ? sizeof(BYTE) : sizeof(WCHAR)), &dwBytesWritten, NULL);
PutPadding(hFile, wPadding2Count, &dwBytesWritten, NULL);
if (isVarFileInfo && wcscmp(szKey, L"Translation") == 0)
{
isVarFileInfo = FALSE;
varResourceChecksum.wLength = sizeof(VarResourceChecksum);
varResourceChecksum.wValueLength = 16; // 128 bits checksum = 16 bytes
varResourceChecksum.wType = 0;
wcscpy(varResourceChecksum.szResourceChecksum, RESOURCE_CHECK_SUM);
memcpy(varResourceChecksum.dwChecksum, pbChecksum, 16);
if (!WriteFile(hFile, &varResourceChecksum, sizeof(VarResourceChecksum), &dwBytesWritten, NULL))
{
bRet = FALSE;
break;
}
}
wTotalLen -= len;
}
LocalFree(newVersionData);
}
}
return (bRet);
}
BOOL CALLBACK EnumNamesFunc(HMODULE hModule, LPCTSTR lpType, LPTSTR lpName, LONG_PTR lParam){
HRSRC hRsrc;
pCommandLineInfo pInfo;
if(lParam == 0)
printf( "MUIBLD: EnumNamesFunc lParam value incorrect (%d)\n", lParam );
pInfo=(pCommandLineInfo)lParam;
if(hRsrc=FindResourceEx(hModule, lpType, lpName, pInfo->wLanguage)){
pInfo->bLanguageFound=TRUE;
}
else{
pInfo->bLanguageFound=FALSE;
return FALSE;
}
if (lpType == MAKEINTRESOURCE(RT_VERSION) && pInfo->bIsResChecksumGenerated)
{
//
// If this is a version resource and resource checksum is generated, call
// the following function to embed the resource checksum into the version
// resource.
//
return (WriteVersionResource(pInfo->hFile, hModule, pInfo->wLanguage, lpName, lpType, hRsrc, pInfo->pResourceChecksum));
}
return (WriteResource(pInfo->hFile, hModule, pInfo->wLanguage, lpName, lpType, hRsrc));
}
BOOL bTypeIncluded(LPCSTR lpType, char **pszIncResType){
char *pszBuf;
char **p;
if (PtrToUlong(lpType) & 0xFFFF0000) {
pszBuf=LocalAlloc(0, strlen(lpType) +1);
if (pszBuf == NULL)
{
ExitFromOutOfMemory();
}
// sprintf(pszBuf, "%s", lpType);
strcpy(pszBuf, lpType);
}
else {
WORD wType = (WORD) lpType;
pszBuf=LocalAlloc(0, sizeof(lpType) + 1);
if (pszBuf == NULL)
{
ExitFromOutOfMemory();
}
sprintf(pszBuf, "%u", wType);
}
p=pszIncResType;
while(p && *p){
if(strcmp(pszBuf, *p)==0)
return TRUE;
p++;
}
LocalFree(pszBuf);
return FALSE;
}
BOOL bInsertHeader(HANDLE hFile){
DWORD dwBytesWritten;
PutByte (hFile, 0x00, &dwBytesWritten, NULL);
PutByte (hFile, 0x00, &dwBytesWritten, NULL);
PutByte (hFile, 0x00, &dwBytesWritten, NULL);
PutByte (hFile, 0x00, &dwBytesWritten, NULL);
PutByte (hFile, 0x20, &dwBytesWritten, NULL);
PutByte (hFile, 0x00, &dwBytesWritten, NULL);
PutByte (hFile, 0x00, &dwBytesWritten, NULL);
PutByte (hFile, 0x00, &dwBytesWritten, NULL);
PutWord (hFile, 0xffff, &dwBytesWritten, NULL);
PutWord (hFile, 0x00, &dwBytesWritten, NULL);
PutWord (hFile, 0xffff, &dwBytesWritten, NULL);
PutWord (hFile, 0x00, &dwBytesWritten, NULL);
PutDWord (hFile, 0L, &dwBytesWritten, NULL);
PutDWord (hFile, 0L, &dwBytesWritten, NULL);
PutDWord (hFile, 0L, &dwBytesWritten, NULL);
PutDWord (hFile, 0L, &dwBytesWritten, NULL);
return TRUE;
}
void PutByte(HANDLE OutFile, TCHAR b, LONG *plSize1, LONG *plSize2){
BYTE temp=b;
if (plSize2){
(*plSize2)++;
}
WriteFile(OutFile, &b, 1, plSize1, NULL);
}
void PutWord(HANDLE OutFile, WORD w, LONG *plSize1, LONG *plSize2){
PutByte(OutFile, (BYTE) LOBYTE(w), plSize1, plSize2);
PutByte(OutFile, (BYTE) HIBYTE(w), plSize1, plSize2);
}
void PutDWord(HANDLE OutFile, DWORD l, LONG *plSize1, LONG *plSize2){
PutWord(OutFile, LOWORD(l), plSize1, plSize2);
PutWord(OutFile, HIWORD(l), plSize1, plSize2);
}
void PutString(HANDLE OutFile, LPCSTR szStr , LONG *plSize1, LONG *plSize2){
WORD i = 0;
do {
PutWord( OutFile , szStr[ i ], plSize1, plSize2);
}
while ( szStr[ i++ ] != TEXT('\0') );
}
void PutStringW(HANDLE OutFile, LPCWSTR szStr , LONG *plSize1, LONG *plSize2){
WORD i = 0;
do {
PutWord( OutFile , szStr[ i ], plSize1, plSize2);
}
while ( szStr[ i++ ] != L'\0' );
}
void PutPadding(HANDLE OutFile, int paddingCount, LONG *plSize1, LONG *plSize2)
{
int i;
for (i = 0; i < paddingCount; i++)
{
PutByte(OutFile, 0x00, plSize1, plSize2);
}
}
void Usage(){
printf("MUIBLD [-h|?] [-c checksum_filename] [-v] -l langid [-i resource_type] source_filename\n");
printf(" [target_filename]\n\n");
}
void CleanUp(pCommandLineInfo pInfo, HANDLE hModule, BOOL bDeleteFile){
if(hModule)
FreeLibrary(hModule);
if(pInfo->hFile)
CloseHandle(pInfo->hFile);
if(bDeleteFile && pInfo->pszTarget)
DeleteFile(pInfo->pszTarget);
}
void FreeAll(pCommandLineInfo pInfo){
char **p;
LocalFree(pInfo->pszSource);
LocalFree(pInfo->pszTarget);
if(pInfo->pszIncResType){
p=pInfo->pszIncResType;
while(p && *p){
LocalFree(*p);
p++;
}
LocalFree(pInfo->pszIncResType);
}
}
void ExitFromOutOfMemory()
{
printf("Out of memory. Can not continue. GetLastError() = 0x%x.", GetLastError());
exit(1);
}
Reference in a new issue Copy permalink