able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/restools/rlt32/rw/win32/win32.cpp

1197 lines
36 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// File: win32.cpp
//
// Contents: Implementation for the Windows 32 Read/Write module
//
// Classes: one
//
// History: 05-Jul-93 alessanm created
//
//----------------------------------------------------------------------------
#include <afxwin.h>
#include "..\common\rwdll.h"
#include "..\common\rw32hlpr.h"
#include <limits.h>
#include <malloc.h>
/////////////////////////////////////////////////////////////////////////////
// Initialization of MFC Extension DLL
#include "afxdllx.h" // standard MFC Extension DLL routines
static AFX_EXTENSION_MODULE NEAR extensionDLL = { NULL, NULL };
/////////////////////////////////////////////////////////////////////////////
// Check sum function
DWORD FixCheckSum( LPCSTR ImageName, LPCSTR OrigFileName, LPCSTR SymbolPath );
/////////////////////////////////////////////////////////////////////////////
// General Declarations
#define RWTAG "WIN32"
static RESSECTDATA ResSectData;
static ULONG gType;
static ULONG gLng;
static ULONG gResId;
static WCHAR gwszResId[256];
static WCHAR gwszTypeId[256];
/////////////////////////////////////////////////////////////////////////////
// Function Declarations
static LONG WriteResInfo(
LPLPBYTE lpBuf, LONG* uiBufSize,
WORD wTypeId, LPSTR lpszTypeId, BYTE bMaxTypeLen,
WORD wNameId, LPSTR lpszNameId, BYTE bMaxNameLen,
DWORD dwLang,
DWORD dwSize, DWORD dwFileOffset );
static UINT GetUpdatedRes(
BYTE far * far* lplpBuffer,
UINT* uiSize,
WORD* wTypeId, LPSTR lplpszTypeId,
WORD* wNameId, LPSTR lplpszNameId,
DWORD* dwlang, DWORD* dwSize );
static UINT GetRes(
BYTE far * far* lplpBuffer,
UINT* puiBufSize,
WORD* wTypeId, LPSTR lplpszTypeId,
WORD* wNameId, LPSTR lplpszNameId,
DWORD* dwLang, DWORD* dwSize, DWORD* dwFileOffset );
static UINT FindResourceSection( CFile*, ULONG_PTR * );
static LONG ReadFile(CFile*, UCHAR *, LONG);
static UINT ParseDirectory( CFile*,
LPLPBYTE lpBuf, UINT* uiBufSize,
BYTE,
PIMAGE_RESOURCE_DIRECTORY,
PIMAGE_RESOURCE_DIRECTORY );
static UINT ParseDirectoryEntry( CFile*,
LPLPBYTE lpBuf, UINT* uiBufSize,
BYTE,
PIMAGE_RESOURCE_DIRECTORY,
PIMAGE_RESOURCE_DIRECTORY_ENTRY );
static UINT ParseSubDir( CFile*,
LPLPBYTE lpBuf, UINT* uiBufSize,
BYTE,
PIMAGE_RESOURCE_DIRECTORY,
PIMAGE_RESOURCE_DIRECTORY_ENTRY );
static UINT ProcessData( CFile*,
LPLPBYTE lpBuf, UINT* uiBufSize,
PIMAGE_RESOURCE_DIRECTORY,
PIMAGE_RESOURCE_DATA_ENTRY );
/////////////////////////////////////////////////////////////////////////////
// Public C interface implementation
//[registration]
extern "C"
BOOL FAR PASCAL RWGetTypeString(LPSTR lpszTypeName)
{
strcpy( lpszTypeName, RWTAG );
return FALSE;
}
extern "C"
BOOL FAR PASCAL RWValidateFileType (LPCSTR lpszFilename)
{
TRACE("WIN32.DLL: RWValidateFileType()\n");
CFile file;
// we Open the file to see if it is a file we can handle
if (!file.Open( lpszFilename, CFile::typeBinary | CFile::modeRead | CFile::shareDenyNone))
return FALSE;
// Read the file signature
WORD w;
file.Read((WORD*)&w, sizeof(WORD));
if (w==IMAGE_DOS_SIGNATURE) {
file.Seek( 0x18, CFile::begin );
file.Read((WORD*)&w, sizeof(WORD));
if (w<0x0040) {
// this is not a Windows Executable
file.Close();
return FALSE;
}
// get offset to header
file.Seek( 0x3c, CFile::begin );
file.Read((WORD*)&w, sizeof(WORD));
// get windows magic word
file.Seek( w, CFile::begin );
file.Read((WORD*)&w, sizeof(WORD));
if (w==LOWORD(IMAGE_NT_SIGNATURE)) {
file.Read((WORD*)&w, sizeof(WORD));
if (w==HIWORD(IMAGE_NT_SIGNATURE)) {
// this is a Windows NT Executable
// we can handle the situation
file.Close();
return TRUE;
}
}
}
file.Close();
return FALSE;
}
extern "C"
DllExport
UINT
APIENTRY
RWReadTypeInfo(
LPCSTR lpszFilename,
LPVOID lpBuffer,
UINT* puiSize
)
{
TRACE("WIN32.DLL: RWReadTypeInfo()\n");
UINT uiError = ERROR_NO_ERROR;
BYTE far * lpBuf = (BYTE far *)lpBuffer;
UINT uiBufSize = *puiSize;
CFile file;
// check if it is a valid win32 file
if (!RWValidateFileType(lpszFilename))
return ERROR_RW_INVALID_FILE;
// Make sure we are using the right code page and global settings
// Get the pointer to the function
HINSTANCE hDllInst = LoadLibrary("iodll.dll");
if (hDllInst)
{
UINT (FAR PASCAL * lpfnGetSettings)(LPSETTINGS);
// Get the pointer to the function to get the settings
lpfnGetSettings = (UINT (FAR PASCAL *)(LPSETTINGS))
GetProcAddress( hDllInst, "RSGetGlobals" );
if (lpfnGetSettings!=NULL) {
SETTINGS settings;
(*lpfnGetSettings)(&settings);
g_cp = settings.cp;
g_bAppend = settings.bAppend;
g_bUpdOtherResLang = settings.bUpdOtherResLang;
strcpy( g_char, settings.szDefChar );
}
FreeLibrary(hDllInst);
}
// Parse the resource tree and extract the information
// Open the file and try to read the information on the resource in it.
if (!file.Open(lpszFilename, CFile::modeRead | CFile::typeBinary | CFile::shareDenyNone))
return ERROR_FILE_OPEN;
// we try to read as much information as we can
// Because this is a res file we can read all the information we need.
UINT uiBufStartSize = uiBufSize;
UCHAR * pResources = LPNULL;
uiError = FindResourceSection( &file, (ULONG_PTR *)&pResources );
if (uiError) {
file.Close();
return uiError;
}
uiError = ParseDirectory( &file,
(LPLPBYTE) &lpBuffer, &uiBufSize,
0,
(PIMAGE_RESOURCE_DIRECTORY)pResources,
(PIMAGE_RESOURCE_DIRECTORY)pResources );
free(pResources);
file.Close();
*puiSize = uiBufStartSize-uiBufSize;
return uiError;
}
extern "C"
DllExport
DWORD
APIENTRY
RWGetImage(
LPCSTR lpszFilename,
DWORD dwImageOffset,
LPVOID lpBuffer,
DWORD dwSize
)
{
UINT uiError = ERROR_NO_ERROR;
BYTE far * lpBuf = (BYTE far *)lpBuffer;
DWORD dwBufSize = dwSize;
// we can consider the use of a CMemFile so we get the same speed as memory access.
CFile file;
// Open the file and try to read the information on the resource in it.
if (!file.Open(lpszFilename, CFile::modeRead | CFile::typeBinary | CFile::shareDenyNone))
return (DWORD)ERROR_FILE_OPEN;
if ( dwImageOffset!=(DWORD)file.Seek( dwImageOffset, CFile::begin) )
return (DWORD)ERROR_FILE_INVALID_OFFSET;
if (dwSize>UINT_MAX) {
// we have to read the image in different steps
return (DWORD)0L;
} else uiError = file.Read( lpBuf, (UINT)dwSize);
file.Close();
return (DWORD)uiError;
}
extern "C"
DllExport
UINT
APIENTRY
RWParseImageEx(
LPCSTR lpszType,
LPCSTR lpszResId,
LPVOID lpImageBuf,
DWORD dwImageSize,
LPVOID lpBuffer,
DWORD dwSize,
LPCSTR lpRCFilename
)
{
UINT uiError = ERROR_NO_ERROR;
BYTE far * lpBuf = (BYTE far *)lpBuffer;
DWORD dwBufSize = dwSize;
// The Type we can parse are only the standard ones
// This function should fill the lpBuffer with an array of ResItem structure
if (HIWORD(lpszType))
{
if (strcmp(lpszType, "REGINST") ==0)
{
return (ParseEmbeddedFile( lpImageBuf, dwImageSize, lpBuffer, dwSize ));
}
}
switch ((UINT)LOWORD(lpszType)) {
case 1:
case 12:
uiError = ParseEmbeddedFile( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 2:
case 14:
uiError = ParseEmbeddedFile( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 3:
uiError = ParseEmbeddedFile( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 4:
uiError = ParseMenu( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 5:
uiError = ParseDialog( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 6:
uiError = ParseString( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 9:
uiError = ParseAccel( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 11:
uiError = ParseMsgTbl( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 16:
uiError = ParseVerst( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 23:
case 240:
case 2110:
case 1024:
uiError = ParseEmbeddedFile( lpImageBuf, dwImageSize, lpBuffer, dwSize );
break;
case 7:
case 8:
case 13:
case 15:
break;
//
// To support RCDATA and user defined function we will call back the iodll,
// get the file name and check if we have a DLL that will handle RCDATA.
// We expect the DLL name to be RCfilename.dll.
// This Dll will export a function called RWParseImageEx. This function will
// be called by the RW to fill the buffer, all this without the iodll knowing.
//
case 10:
default:
//
// Get the file name from the iodll
//
if(lpRCFilename && strcmp(lpRCFilename, ""))
{
// try to Load the dll
HINSTANCE hRCDllInst = LoadLibrary(lpRCFilename);
if (hRCDllInst)
{
UINT (FAR PASCAL * lpfnParseImageEx)(LPCSTR, LPCSTR, LPVOID, DWORD, LPVOID, DWORD, LPCSTR);
// Get the pointer to the function to extract the resources
lpfnParseImageEx = (UINT (FAR PASCAL *)(LPCSTR, LPCSTR, LPVOID, DWORD, LPVOID, DWORD, LPCSTR))
GetProcAddress( hRCDllInst, "RWParseImageEx" );
if (lpfnParseImageEx)
{
uiError = (*lpfnParseImageEx)(lpszType,
lpszResId,
lpImageBuf,
dwImageSize,
lpBuffer,
dwSize,
NULL);
}
FreeLibrary(hRCDllInst);
}
}
break;
}
return uiError;
}
extern "C"
DllExport
UINT
APIENTRY
RWParseImage(
LPCSTR lpszType,
LPVOID lpImageBuf,
DWORD dwImageSize,
LPVOID lpBuffer,
DWORD dwSize
)
{
//
// Just a wrapper to be compatible...
//
return RWParseImageEx(lpszType, NULL, lpImageBuf, dwImageSize, lpBuffer, dwSize, NULL);
}
extern"C"
DllExport
UINT
APIENTRY
RWWriteFile(
LPCSTR lpszSrcFilename,
LPCSTR lpszTgtFilename,
HANDLE hResFileModule,
LPVOID lpBuffer,
UINT uiSize,
HINSTANCE hDllInst,
LPCSTR lpszSymbolPath
)
{
UINT uiError = ERROR_NO_ERROR;
UINT uiBufSize = uiSize;
CFile fileIn;
CFile fileOut;
BOOL bfileIn = TRUE;
// Open the file and try to read the information on the resource in it.
CFileStatus status;
if (CFile::GetStatus( lpszSrcFilename, status )) {
// check if the size of the file is not null
if (!status.m_size)
CFile::Remove(lpszSrcFilename);
}
if (!fileIn.Open(lpszSrcFilename, CFile::modeRead | CFile::typeBinary | CFile::shareDenyNone))
return ERROR_FILE_OPEN;
if (!fileOut.Open(lpszTgtFilename, CFile::modeWrite | CFile::modeCreate | CFile::typeBinary))
return ERROR_FILE_CREATE;
// Create a copy of the US file
uiError = CopyFile( &fileIn, &fileOut );
fileIn.Close();
fileOut.Close();
// Get the pointer to the function
hDllInst = LoadLibrary("iodll.dll");
if (!hDllInst)
return ERROR_DLL_LOAD;
DWORD (FAR PASCAL * lpfnGetImage)(HANDLE, LPCSTR, LPCSTR, DWORD, LPVOID, DWORD);
// Get the pointer to the function to extract the resources image
lpfnGetImage = (DWORD (FAR PASCAL *)(HANDLE, LPCSTR, LPCSTR, DWORD, LPVOID, DWORD))
GetProcAddress( hDllInst, "RSGetResImage" );
if (lpfnGetImage==NULL) {
FreeLibrary(hDllInst);
return (UINT)GetLastError()+LAST_ERROR;
}
// We read the resources from the file and then we check if the resource has been updated
// or if we can just copy it
WORD wTypeId;
char szTypeId[128];
WORD wNameId;
char szNameId[128];
DWORD dwSize;
DWORD dwLang;
WORD wUpdTypeId = 0;
static char szUpdTypeId[128];
WORD wUpdNameId;
static char szUpdNameId[128];
static WCHAR szwTypeId[128];
static WCHAR szwNameId[128];
DWORD dwUpdLang = 0;
DWORD dwUpdSize = 0;
UINT uiBufStartSize = uiBufSize;
DWORD dwImageBufSize;
DWORD dwLstErr = 0l;
BYTE * lpImageBuf;
static WCHAR szwTgtFilename[400];
SetLastError(0);
// Convert the Target file name to a unicode name
_MBSTOWCS(szwTgtFilename, (char *)lpszTgtFilename, 400 );
// Get the updated resource and replace them
HANDLE hUpd = BeginUpdateResourceW( (LPCWSTR)&szwTgtFilename[0], !g_bAppend );
dwLstErr = GetLastError();
if (!hUpd) {
FreeLibrary(hDllInst);
return((UINT)dwLstErr);
}
// Parse the original file an get the list of resources
UINT uiBSize = 100000;
BYTE far * lpBuf = new far BYTE[uiBSize];
BYTE far * lpStartBuf = lpBuf;
if (!lpBuf) {
FreeLibrary(hDllInst);
return ERROR_NEW_FAILED;
}
uiError = RWReadTypeInfo( lpszSrcFilename, (LPVOID)lpBuf, &uiBSize );
if (uiError!=ERROR_NO_ERROR) {
FreeLibrary(hDllInst);
delete lpBuf;
return uiError;
}
DWORD dwDummy;
while(uiBSize>0) {
if (uiBSize)
GetRes( &lpBuf,
&uiBSize,
&wTypeId, &szTypeId[0],
&wNameId, &szNameId[0],
&dwLang,
&dwSize,
&dwDummy
);
dwLang = MAKELONG(LOWORD(dwLang),LOWORD(dwLang));
if ((!wUpdTypeId) && (uiBufSize))
GetUpdatedRes( (BYTE**)&lpBuffer,
&uiBufSize,
&wUpdTypeId, &szUpdTypeId[0],
&wUpdNameId, &szUpdNameId[0],
&dwUpdLang,
&dwUpdSize
);
// check if the resource has been updated or not
if ( (wUpdTypeId==wTypeId) &&
( (CString)szUpdTypeId==(CString)szTypeId) &&
(wUpdNameId==wNameId) &&
( (CString)szUpdNameId==(CString)szNameId) &&
(LOWORD(dwLang) == LOWORD(dwUpdLang))
) {
dwLang = dwUpdLang;
dwSize = dwUpdSize;
wUpdTypeId = 0;
}
// all resources of specific language need to be marked
if (LOWORD(dwLang) == LOWORD(dwUpdLang) && g_bUpdOtherResLang)
{
dwLang = dwUpdLang;
}
// The resource has been updated get the image from the IODLL
lpImageBuf = new BYTE[dwSize];
// convert the Name to unicode
LPWSTR lpUpdType = LPNULL;
LPWSTR lpUpdRes = LPNULL;
LPCSTR lpType = LPNULL;
LPCSTR lpRes = LPNULL;
if (wTypeId) {
lpUpdType = (LPWSTR) MAKEINTRESOURCE((WORD)wTypeId);
lpType = MAKEINTRESOURCE((WORD)wTypeId);
} else {
SetLastError(0);
_MBSTOWCS(szwTypeId, szTypeId, 128 );
// Check for error
if(GetLastError()) {
FreeLibrary(hDllInst);
return ERROR_DLL_LOAD;
}
lpUpdType = (LPWSTR) &szwTypeId[0];
lpType = &szTypeId[0];
}
if (wNameId) {
lpUpdRes = (LPWSTR) MAKEINTRESOURCE((WORD)wNameId);
lpRes = MAKEINTRESOURCE((WORD)wNameId);
} else {
SetLastError(0);
_MBSTOWCS(szwNameId, szNameId, 128 );
// Check for error
if(GetLastError()) {
FreeLibrary(hDllInst);
return ERROR_DLL_LOAD;
}
lpUpdRes = (LPWSTR) &szwNameId[0];
lpRes = &szNameId[0];
}
dwImageBufSize = (*lpfnGetImage)( hResFileModule,
lpType,
lpRes,
(DWORD)LOWORD(dwLang),
lpImageBuf,
dwSize
);
if (dwImageBufSize>dwSize ) {
// The buffer is too small
delete []lpImageBuf;
lpImageBuf = new BYTE[dwImageBufSize];
dwUpdSize = (*lpfnGetImage)( hResFileModule,
lpType,
lpRes,
(DWORD)LOWORD(dwLang),
lpImageBuf,
dwImageBufSize
);
if ((dwUpdSize-dwImageBufSize)!=0 ) {
delete []lpImageBuf;
lpImageBuf = LPNULL;
}
}else if (dwImageBufSize==0){
delete []lpImageBuf;
lpImageBuf = LPNULL;
}
SetLastError(0);
TRACE1("\t\tUpdateResourceW: %d\n", (WORD)dwUpdLang);
if(!UpdateResourceW( hUpd,
lpUpdType,
lpUpdRes,
HIWORD(dwLang),
(LPVOID)lpImageBuf,
dwImageBufSize ))
{
dwLstErr = GetLastError();
}
if (lpImageBuf) delete []lpImageBuf;
}
SetLastError(0);
EndUpdateResourceW( hUpd, FALSE );
dwLstErr = GetLastError();
if (dwLstErr)
dwLstErr +=LAST_ERROR;
// Fix the check sum
DWORD error;
if(error = FixCheckSum(lpszTgtFilename,lpszSrcFilename, lpszSymbolPath))
dwLstErr = error;
delete lpStartBuf;
FreeLibrary(hDllInst);
return (UINT)dwLstErr;
}
extern "C"
DllExport
UINT
APIENTRY
RWUpdateImageEx(
LPCSTR lpszType,
LPVOID lpNewBuf,
DWORD dwNewSize,
LPVOID lpOldImage,
DWORD dwOldImageSize,
LPVOID lpNewImage,
DWORD* pdwNewImageSize,
LPCSTR lpRCFilename
)
{
UINT uiError = ERROR_NO_ERROR;
// The Type we can parse are only the standard ones
switch ((UINT)LOWORD(lpszType)) {
case 4:
uiError = UpdateMenu( lpNewBuf, dwNewSize,
lpOldImage, dwOldImageSize,
lpNewImage, pdwNewImageSize );
break;
case 5:
uiError = UpdateDialog( lpNewBuf, dwNewSize,
lpOldImage, dwOldImageSize,
lpNewImage, pdwNewImageSize );
break;
case 6:
uiError = UpdateString( lpNewBuf, dwNewSize,
lpOldImage, dwOldImageSize,
lpNewImage, pdwNewImageSize );
break;
case 9:
uiError = UpdateAccel( lpNewBuf, dwNewSize,
lpOldImage, dwOldImageSize,
lpNewImage, pdwNewImageSize );
break;
case 11:
uiError = UpdateMsgTbl( lpNewBuf, dwNewSize,
lpOldImage, dwOldImageSize,
lpNewImage, pdwNewImageSize );
break;
case 16:
uiError = UpdateVerst( lpNewBuf, dwNewSize,
lpOldImage, dwOldImageSize,
lpNewImage, pdwNewImageSize );
break;
default:
//
// Get the file name from the iodll
//
if(lpRCFilename && strcmp(lpRCFilename, ""))
{
// try to Load the dll
HINSTANCE hRCDllInst = LoadLibrary(lpRCFilename);
if (hRCDllInst)
{
UINT (FAR PASCAL * lpfnGenerateImageEx)(LPCSTR, LPVOID, DWORD, LPVOID, DWORD, LPVOID, DWORD*, LPCSTR);
lpfnGenerateImageEx = (UINT (FAR PASCAL *)(LPCSTR, LPVOID, DWORD, LPVOID, DWORD, LPVOID, DWORD*, LPCSTR))
GetProcAddress( hRCDllInst, "RWUpdateImageEx" );
if (lpfnGenerateImageEx)
{
uiError = (*lpfnGenerateImageEx)( lpszType,
lpNewBuf,
dwNewSize,
lpOldImage,
dwOldImageSize,
lpNewImage,
pdwNewImageSize,
NULL );
}
else
{
*pdwNewImageSize = 0L;
uiError = ERROR_RW_NOTREADY;
}
FreeLibrary(hRCDllInst);
}
else
{
*pdwNewImageSize = 0L;
uiError = ERROR_RW_NOTREADY;
}
}
else
{
*pdwNewImageSize = 0L;
uiError = ERROR_RW_NOTREADY;
}
break;
}
return uiError;
}
extern "C"
DllExport
UINT
APIENTRY
RWUpdateImage(
LPCSTR lpszType,
LPVOID lpNewBuf,
DWORD dwNewSize,
LPVOID lpOldImage,
DWORD dwOldImageSize,
LPVOID lpNewImage,
DWORD* pdwNewImageSize
)
{
return RWUpdateImageEx(lpszType, lpNewBuf, dwNewSize,
lpOldImage, dwOldImageSize, lpNewImage, pdwNewImageSize,
NULL);
}
///////////////////////////////////////////////////////////////////////////
// Functions implementation
static UINT
GetResInfo( CFile* pfile,
WORD* pwTypeId, LPSTR lpszTypeId, BYTE bMaxTypeLen,
WORD* pwNameId, LPSTR lpszNameId, BYTE bMaxNameLen,
WORD* pwFlags,
DWORD* pdwSize, DWORD* pdwFileOffset )
{
// Here we will parese the win32 file and will extract the information on the
// resources included in the file.
// Let's go and get the .rsrc sections
UINT uiError = ERROR_NO_ERROR;
return 1;
}
static UINT FindResourceSection( CFile* pfile, ULONG_PTR * pRes )
{
UINT uiError = ERROR_NO_ERROR;
LONG lRead;
// We check again that is a file we can handle
WORD w;
pfile->Read((WORD*)&w, sizeof(WORD));
if (w!=IMAGE_DOS_SIGNATURE) return ERROR_RW_INVALID_FILE;
pfile->Seek( 0x18, CFile::begin );
pfile->Read((WORD*)&w, sizeof(WORD));
if (w<0x0040) {
// this is not a Windows Executable
return ERROR_RW_INVALID_FILE;
}
// get offset to new header
pfile->Seek( 0x3c, CFile::begin );
pfile->Read((WORD*)&w, sizeof(WORD));
// read windows new header
static IMAGE_NT_HEADERS NTHdr;
pfile->Seek( w, CFile::begin );
pfile->Read(&NTHdr, sizeof(IMAGE_NT_HEADERS));
// Check if the magic word is the right one
if (NTHdr.Signature!=IMAGE_NT_SIGNATURE)
return ERROR_RW_INVALID_FILE;
// Check if the we have 64-bit image
#ifdef _WIN64
if (NTHdr.OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR64_MAGIC)
pfile->Seek(IMAGE_SIZEOF_NT_OPTIONAL32_HEADER -
IMAGE_SIZEOF_NT_OPTIONAL64_HEADER,
CFile::current);
#else
if (NTHdr.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)
pfile->Seek(IMAGE_SIZEOF_NT_OPTIONAL64_HEADER -
IMAGE_SIZEOF_NT_OPTIONAL32_HEADER,
CFile::current);
#endif
// this is a Windows NT Executable
// we can handle the situation
// Later we want to check for the file type
// Read the section table
UINT uisize = sizeof(IMAGE_SECTION_HEADER)
* NTHdr.FileHeader.NumberOfSections;
PIMAGE_SECTION_HEADER pSectTbl =
new IMAGE_SECTION_HEADER[NTHdr.FileHeader.NumberOfSections];
if (pSectTbl==LPNULL)
return ERROR_NEW_FAILED;
// Clean the memory we allocated
memset( (PVOID)pSectTbl, 0, uisize);
lRead = pfile->Read(pSectTbl, uisize);
if (lRead!=(LONG)uisize) {
delete []pSectTbl;
return ERROR_FILE_READ;
}
PIMAGE_SECTION_HEADER pResSect = NULL;
PIMAGE_SECTION_HEADER pResSect1 = NULL;
// Check all the sections for the .rsrc or .rsrc1
USHORT us =0;
for (PIMAGE_SECTION_HEADER pSect = pSectTbl;
us < NTHdr.FileHeader.NumberOfSections; us++ ) {
if ( !strcmp((char*)pSect->Name, ".rsrc") && (!pResSect)) {
pResSect = pSect;
} else if (!strcmp((char*)pSect->Name, ".rsrc1") && (!pResSect1)) {
// This mean that the binary we are parsing
// has been already updated using UpdateResource()
pResSect1 = pSect;
}
pSect++;
}
if (!pResSect) {
delete []pSectTbl;
return ERROR_RW_NO_RESOURCES;
}
// Read the resources in memory
ResSectData.ulOffsetToResources = pResSect->PointerToRawData;
ResSectData.ulOffsetToResources1 = pResSect1 ? pResSect1->PointerToRawData
: LPNULL;
ResSectData.ulVirtualAddress = pResSect->VirtualAddress;
ResSectData.ulSizeOfResources = pResSect->SizeOfRawData;
ResSectData.ulVirtualAddress1 = pResSect1 ? pResSect1->VirtualAddress
: LPNULL;
ResSectData.ulSizeOfResources1 = pResSect1 ? pResSect1->SizeOfRawData
: 0L;
UCHAR * pResources = (UCHAR *) malloc((ResSectData.ulSizeOfResources
+ResSectData.ulSizeOfResources1));
if (pResources==LPNULL) {
delete []pSectTbl;
return ERROR_NEW_FAILED;
}
// We read the data for the first section
pfile->Seek( (LONG)ResSectData.ulOffsetToResources, CFile::begin);
lRead = ReadFile(pfile, pResources, (LONG)ResSectData.ulSizeOfResources);
if (lRead!=(LONG)ResSectData.ulSizeOfResources) {
delete []pSectTbl;
free(pResources);
return ERROR_FILE_READ;
}
// We read the data for the second section
if (ResSectData.ulSizeOfResources1 > 0L) {
pfile->Seek( (LONG)ResSectData.ulOffsetToResources1, CFile::begin);
lRead = ReadFile( pfile, (pResources+ResSectData.ulSizeOfResources),
(LONG)ResSectData.ulSizeOfResources1);
if (lRead!=(LONG)ResSectData.ulSizeOfResources1) {
delete []pSectTbl;
free(pResources);
return ERROR_FILE_READ;
}
}
delete []pSectTbl;
// We want to copy the pointer to the resources
*pRes = (ULONG_PTR)pResources;
return uiError;
}
static UINT ParseDirectory( CFile* pfile,
LPLPBYTE lplpBuf, UINT* puiBufSize,
BYTE bLevel,
PIMAGE_RESOURCE_DIRECTORY pResStart,
PIMAGE_RESOURCE_DIRECTORY pResDir)
{
PIMAGE_RESOURCE_DIRECTORY_ENTRY pResDirStart;
// Get the pointer to the first entry
pResDirStart = (PIMAGE_RESOURCE_DIRECTORY_ENTRY)
((BYTE far *)pResDir + sizeof( IMAGE_RESOURCE_DIRECTORY));
UINT uiError = 0;
UINT uiCount = pResDir->NumberOfNamedEntries
+ pResDir->NumberOfIdEntries;
for ( PIMAGE_RESOURCE_DIRECTORY_ENTRY pResDirEntry = pResDirStart;
pResDirEntry < pResDirStart+uiCount && uiError == 0;
++pResDirEntry )
{
if (bLevel==0) GetNameOrOrdU( (PUCHAR) pResStart,
pResDirEntry->Name,
(LPWSTR)&gwszTypeId,
&gType );
if (bLevel==1) GetNameOrOrdU( (PUCHAR) pResStart,
pResDirEntry->Name,
(LPWSTR)&gwszResId,
&gResId );
if (bLevel==2) gLng = pResDirEntry->Name;
// Check if the user want to get all the resources
// or only some of them
uiError = ParseDirectoryEntry( pfile,
lplpBuf, puiBufSize,
bLevel,
pResStart,
pResDirEntry );
}
return uiError;
}
static UINT ParseDirectoryEntry( CFile * pfile,
LPLPBYTE lplpBuf, UINT* puiBufSize,
BYTE bLevel,
PIMAGE_RESOURCE_DIRECTORY pResStart,
PIMAGE_RESOURCE_DIRECTORY_ENTRY pResDirEntry)
{
UINT uiError;
// Check if it is a SubDir or if it is a final Node
if (pResDirEntry->OffsetToData & IMAGE_RESOURCE_DATA_IS_DIRECTORY) {
// It is a SubDir
uiError = ParseSubDir( pfile,
lplpBuf, puiBufSize,
bLevel,
pResStart,
pResDirEntry );
} else {
uiError = ProcessData( pfile,
lplpBuf, puiBufSize,
pResStart,
(PIMAGE_RESOURCE_DATA_ENTRY)((BYTE far *)pResStart
+ pResDirEntry->OffsetToData));
}
return uiError;
}
static UINT ParseSubDir( CFile * pfile,
LPLPBYTE lplpBuf, UINT* puiBufSize,
BYTE bLevel,
PIMAGE_RESOURCE_DIRECTORY pResStart,
PIMAGE_RESOURCE_DIRECTORY_ENTRY pResDirEntry)
{
PIMAGE_RESOURCE_DIRECTORY pResDir;
pResDir = (PIMAGE_RESOURCE_DIRECTORY)((BYTE far *)pResStart
+ (pResDirEntry->OffsetToData &
(~IMAGE_RESOURCE_DATA_IS_DIRECTORY)));
return( ++bLevel < MAXLEVELS ? ParseDirectory( pfile,
lplpBuf, puiBufSize,
bLevel,
pResStart,
pResDir)
: ERROR_RW_TOO_MANY_LEVELS);
}
static UINT ProcessData( CFile * pfile,
LPLPBYTE lplpBuf, UINT* puiBufSize,
PIMAGE_RESOURCE_DIRECTORY pResStart,
PIMAGE_RESOURCE_DATA_ENTRY pResData)
{
UINT uiError = ERROR_NO_ERROR;
// Let's calculate the offset to the data
ULONG ulOffset = pResData->OffsetToData - ResSectData.ulVirtualAddress;
if ( ulOffset >= ResSectData.ulSizeOfResources ) {
if ( ResSectData.ulSizeOfResources1 > 0L ) {
// What we need is in the .rsrc1 segment
// Recalculate the offset;
ulOffset = pResData->OffsetToData - ResSectData.ulVirtualAddress1;
if ( ulOffset >= ResSectData.ulSizeOfResources +
ResSectData.ulSizeOfResources1) {
// There is an error in the offset
return ERROR_FILE_INVALID_OFFSET;
} else ulOffset += ResSectData.ulOffsetToResources1;
} else return ERROR_FILE_INVALID_OFFSET;
} else ulOffset += ResSectData.ulOffsetToResources;
// Convert the UNICODE to SB string
static char szResName[128];
UINT cch = _WCSLEN(gwszResId);
_WCSTOMBS( szResName, gwszResId, 128 );
static char szTypeName[128];
cch = _WCSLEN(gwszTypeId);
_WCSTOMBS( szTypeName, gwszTypeId, 128 );
TRACE("WIN32.DLL:\tType: %ld\tType Name: %s\tLang: %ld\tRes Id: %ld", gType, szTypeName, gLng, gResId);
TRACE1("\tSize: %d", pResData->Size);
TRACE2("\tRes Name: %s\tOffset: %lX\n", szResName, ulOffset );
// fill the buffer
WriteResInfo(lplpBuf, (LONG*)puiBufSize,
(WORD)gType, szTypeName, 128,
(WORD)gResId, szResName, 128,
(DWORD)gLng,
(DWORD)pResData->Size, (DWORD)ulOffset );
return uiError;
};
static LONG WriteResInfo(
LPLPBYTE lplpBuffer, LONG* plBufSize,
WORD wTypeId, LPSTR lpszTypeId, BYTE bMaxTypeLen,
WORD wNameId, LPSTR lpszNameId, BYTE bMaxNameLen,
DWORD dwLang,
DWORD dwSize, DWORD dwFileOffset )
{
LONG lSize = 0;
lSize = PutWord( lplpBuffer, wTypeId, plBufSize );
lSize += PutStringA( lplpBuffer, lpszTypeId, plBufSize );
// Check if it is alligned
lSize += Allign( lplpBuffer, plBufSize, lSize);
lSize += PutWord( lplpBuffer, wNameId, plBufSize );
lSize += PutStringA( lplpBuffer, lpszNameId, plBufSize );
lSize += Allign( lplpBuffer, plBufSize, lSize);
lSize += PutDWord( lplpBuffer, dwLang, plBufSize );
lSize += PutDWord( lplpBuffer, dwSize, plBufSize );
lSize += PutDWord( lplpBuffer, dwFileOffset, plBufSize );
return (LONG)lSize;
}
static UINT GetUpdatedRes(
BYTE far * far* lplpBuffer,
UINT* puiBufSize,
WORD* wTypeId, LPSTR lplpszTypeId,
WORD* wNameId, LPSTR lplpszNameId,
DWORD* dwLang, DWORD* dwSize )
{
UINT uiSize = 0l;
LONG lSize = *puiBufSize;
uiSize = GetWord( lplpBuffer, wTypeId, (LONG*)&lSize );
uiSize += GetStringA( lplpBuffer, lplpszTypeId, (LONG*)&lSize );
uiSize += SkipByte( lplpBuffer, PadPtr(uiSize), (LONG*)&lSize );
uiSize += GetWord( lplpBuffer, wNameId, (LONG*)&lSize );
uiSize += GetStringA( lplpBuffer, lplpszNameId, (LONG*)&lSize );
uiSize += SkipByte( lplpBuffer, PadPtr(uiSize), (LONG*)&lSize );
uiSize += GetDWord( lplpBuffer, dwLang, (LONG*)&lSize );
uiSize += GetDWord( lplpBuffer, dwSize, (LONG*)&lSize );
*puiBufSize = lSize;
return 0;
}
static UINT GetRes(
BYTE far * far* lplpBuffer,
UINT* puiBufSize,
WORD* wTypeId, LPSTR lplpszTypeId,
WORD* wNameId, LPSTR lplpszNameId,
DWORD* dwLang, DWORD* dwSize, DWORD* dwFileOffset )
{
UINT uiSize = 0l;
LONG lSize = *puiBufSize;
uiSize = GetWord( lplpBuffer, wTypeId, (LONG*)&lSize );
uiSize += GetStringA( lplpBuffer, lplpszTypeId, (LONG*)&lSize );
uiSize += SkipByte( lplpBuffer, PadPtr(uiSize), (LONG*)&lSize );
uiSize += GetWord( lplpBuffer, wNameId, (LONG*)&lSize );
uiSize += GetStringA( lplpBuffer, lplpszNameId, (LONG*)&lSize );
uiSize += SkipByte( lplpBuffer, PadPtr(uiSize), (LONG*)&lSize );
uiSize += GetDWord( lplpBuffer, dwLang, (LONG*)&lSize );
uiSize += GetDWord( lplpBuffer, dwSize, (LONG*)&lSize );
uiSize += GetDWord( lplpBuffer, dwFileOffset, (LONG*)&lSize );
*puiBufSize = lSize;
return uiSize;
}
static LONG ReadFile(CFile* pFile, UCHAR * pBuf, LONG lRead)
{
LONG lLeft = lRead;
WORD wRead = 0;
DWORD dwOffset = 0;
while(lLeft>0){
wRead =(WORD) (32738ul < lLeft ? 32738: lLeft);
if (wRead!=_lread( (HFILE)pFile->m_hFile, (UCHAR *)pBuf+dwOffset, wRead))
return 0l;
lLeft -= wRead;
dwOffset += wRead;
}
return dwOffset;
}
////////////////////////////////////////////////////////////////////////////
// DLL Specific code implementation
////////////////////////////////////////////////////////////////////////////
// Library init
////////////////////////////////////////////////////////////////////////////
// This function should be used verbatim. Any initialization or termination
// requirements should be handled in InitPackage() and ExitPackage().
//
extern "C" int APIENTRY
DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
// NOTE: global/static constructors have already been called!
// Extension DLL one-time initialization - do not allocate memory
// here, use the TRACE or ASSERT macros or call MessageBox
AfxInitExtensionModule(extensionDLL, hInstance);
}
else if (dwReason == DLL_PROCESS_DETACH)
{
// Terminate the library before destructors are called
AfxWinTerm();
}
if (dwReason == DLL_PROCESS_DETACH || dwReason == DLL_THREAD_DETACH)
return 0; // CRT term Failed
return 1; // ok
}
/////////////////////////////////////////////////////////////////////////////
Reference in a new issue Copy permalink