long int WRReadWinNTExeHeader( WResFileID file_handle, exe_pe_header *header )
{
long int old_pos;
uint_16 offset;
bool ok;
old_pos = -1;
ok = (file_handle != -1 && header != NULL);
if( ok ) {
ok = ((old_pos = ResSeek( file_handle, 0x18, SEEK_SET )) != -1);
}
/* check the reloc offset */
if( ok ) {
ResReadUint16( &offset, file_handle );
ok = (offset >= 0x0040);
}
if( ok ) {
ok = (ResSeek( file_handle, PE_OFFSET, SEEK_SET ) != -1);
}
/* check header offset */
if( ok ) {
ResReadUint16( &offset, file_handle );
ok = (offset != 0x0000);
}
if( ok ) {
ok = (ResSeek( file_handle, offset, SEEK_SET ) != -1);
}
if( ok ) {
ok = (read( file_handle, &PE32( *header ), sizeof( pe_header ) ) == sizeof( pe_header ));
if( ok && IS_PE64( *header ) ) {
ok = (ResSeek( file_handle, offset, SEEK_SET ) != -1);
if( ok ) {
ok = (read( file_handle, &PE64( *header ), sizeof( pe_header64 ) ) == sizeof( pe_header64 ));
}
}
}
/* check for valid Win32 EXE */
if( ok ) {
ok = WRIsHeaderValidWINNT( header );
}
if( old_pos != -1 ) {
ok = (ResSeek( file_handle, old_pos, SEEK_SET ) != -1 && ok);
}
if( !ok ) {
WRDisplayErrorMsg( WR_INVALIDNTEXE );
offset = 0;
}
return( offset );
}
bool ResReadMenuItem32( MenuItem *curritem, WResFileID handle )
/************************************************************/
{
bool error;
uint_16 tmp16;
error = ResReadUint16( &tmp16, handle );
curritem->Item.Popup.ItemFlags = tmp16;
if( !error ) {
if( curritem->Item.Popup.ItemFlags & MENU_POPUP ) {
curritem->IsPopup = true;
curritem->Item.Popup.ItemText = ResRead32String( handle, NULL );
error = (curritem->Item.Popup.ItemText == NULL);
} else {
curritem->IsPopup = false;
error = ResReadUint16( &tmp16, handle );
curritem->Item.Normal.ItemID = tmp16;
if( !error ) {
curritem->Item.Normal.ItemText = ResRead32String( handle, NULL );
error = (curritem->Item.Normal.ItemText == NULL);
}
}
}
return( error );
}
long int WRReadWin16ExeHeader( WResFileID file_handle, os2_exe_header *header )
{
long int old_pos;
uint_16 offset;
int ok;
old_pos = -1;
ok = (file_handle != -1 && header != NULL);
if( ok ) {
ok = ((old_pos = ResSeek( file_handle, 0x18, SEEK_SET )) != -1);
}
/* check the reloc offset */
if( ok ) {
ResReadUint16( &offset, file_handle );
ok = (offset >= 0x0040);
}
if( ok ) {
ok = (ResSeek( file_handle, OS2_NE_OFFSET, SEEK_SET ) != -1);
}
/* check header offset */
if( ok ) {
ResReadUint16( &offset, file_handle );
ok = (offset != 0x0000);
}
if( ok ) {
ok = (ResSeek( file_handle, offset, SEEK_SET ) != -1);
}
if( ok ) {
ok = (read( file_handle, header, sizeof( os2_exe_header ) ) ==
sizeof( os2_exe_header ));
}
/* check for valid Win16 EXE */
if( ok ) {
ok = WRIsHeaderValidWIN16( header );
}
if( old_pos != -1 ) {
ok = (ResSeek( file_handle, old_pos, SEEK_SET ) != -1 && ok);
}
if( ok ) {
return( offset );
} else {
return( 0 );
}
}
ResNameOrOrdinal *ResRead32NameOrOrdinal( WResFileID handle )
/***********************************************************/
{
uint_16 flags;
uint_16 ord;
ResNameOrOrdinal * newptr;
int error;
int stringlen;
char * restofstr;
restofstr = NULL;
ord = 0;
stringlen = 0;
error = ResReadUint16( &flags, handle );
/* read the rest of the Name or Ordinal */
if( !error ) {
if( flags == 0xffff ) {
error = ResReadUint16( &ord, handle );
} else {
if( flags != 0x0000 ) {
restofstr = ResRead32String( handle, &stringlen );
stringlen += 1; /* for the '\0' */
error = (restofstr == NULL);
}
}
}
/* allocate space for the new Name or Ordinal */
if( error ) {
newptr = NULL;
} else {
newptr = WRESALLOC( sizeof(ResNameOrOrdinal) + stringlen );
error = (newptr == NULL);
if( error ) WRES_ERROR( WRS_MALLOC_FAILED );
}
/* copy the new new Name or Ordinal into the correct place */
if( !error ) {
if( flags == 0xffff ) {
newptr->ord.fFlag = 0xff;
newptr->ord.wOrdinalID = ord;
} else {
newptr->name[0] = (char)(flags & 0x00ff);
if( flags != 0x0000 ) {
memcpy( &(newptr->name[1]), restofstr, stringlen );
WRESFREE( restofstr );
}
}
}
return( newptr );
}
int WRCalcObjTableOffset( WResFileID file, exe_pe_header *hdr )
{
uint_16 pe_offset;
int offset;
bool ok;
ok = (ResSeek( file, PE_OFFSET, SEEK_SET ) != -1);
if( ok ) {
ResReadUint16( &pe_offset, file );
ok = (pe_offset != 0);
}
if ( ok ) {
if( IS_PE64( *hdr ) ) {
offset = pe_offset + PE64( *hdr ).nt_hdr_size + offsetof( pe_header64, magic );
} else {
offset = pe_offset + PE32( *hdr ).nt_hdr_size + offsetof( pe_header, magic );
}
} else {
offset = 0;
}
return( offset );
}
WResTypeNode *WRReadWResTypeNodeFromExe( WResFileID file_handle, uint_16 align_shift )
{
uint_16 type_id;
uint_16 resource_count;
uint_32 reserved;
WResTypeNode *type_node;
WResResNode *res_node;
ResReadUint16( &type_id, file_handle );
if( type_id == 0x0000 ) {
return( NULL );
}
type_node = (WResTypeNode *)WRMemAlloc( sizeof( WResTypeNode ) );
if( type_node == NULL ) {
return( NULL );
}
ResReadUint16( &resource_count, file_handle );
ResReadUint32( &reserved, file_handle );
type_node->Next = NULL;
type_node->Prev = NULL;
type_node->Head = NULL;
type_node->Tail = NULL;
type_node->Info.NumResources = resource_count;
if( type_id & 0x8000 ) {
type_node->Info.TypeName.IsName = FALSE;
} else {
type_node->Info.TypeName.IsName = TRUE;
}
type_node->Info.TypeName.ID.Num = (type_id & 0x7fff);
for( ; resource_count != 0; resource_count-- ) {
res_node = WRReadWResResNodeFromExe( file_handle, align_shift );
if( type_node->Head == NULL ) {
type_node->Head = res_node;
}
if( type_node->Tail != NULL ) {
type_node->Tail->Next = res_node;
}
res_node->Prev = type_node->Tail;
type_node->Tail = res_node;
}
return( type_node );
}
ResNameOrOrdinal *ResReadNameOrOrdinal( WResFileID handle )
/*********************************************************/
{
ResNameOrOrdinal newname;
ResNameOrOrdinal * newptr;
int error;
int stringlen;
char * restofstr;
uint_8 tmp8;
uint_16 tmp16;
restofstr = NULL;
error = ResReadUint8( &tmp8, handle );
newname.ord.fFlag = tmp8;
newname.ord.wOrdinalID = 0;
stringlen = 0;
/* read the rest of the Name or Ordinal */
if (!error) {
if (newname.ord.fFlag == 0xff) {
error = ResReadUint16( &tmp16, handle );
newname.ord.wOrdinalID = tmp16;
} else {
if (newname.name[0] != '\0') {
restofstr = ResReadString( handle, &stringlen );
stringlen += 1; /* for the '\0' */
error = (restofstr == NULL);
}
}
}
/* allocate space for the new Name or Ordinal */
if (error) {
newptr = NULL;
} else {
newptr = WRESALLOC( sizeof(ResNameOrOrdinal) + stringlen );
error = (newptr == NULL);
if( error ) WRES_ERROR( WRS_MALLOC_FAILED );
}
/* copy the new new Name or Ordinal into the correct place */
if (!error) {
newptr->ord.fFlag = newname.ord.fFlag;
if (newname.ord.fFlag == 0xff) {
newptr->ord.wOrdinalID = newname.ord.wOrdinalID;
} else {
if (newptr->name[0] != '\0') {
memcpy( &(newptr->name[1]), restofstr, stringlen );
WRESFREE( restofstr );
}
}
}
return( newptr );
}
bool ResReadMenuExItem( MenuExItem *curritem, WResFileID handle )
/***************************************************************/
{
bool error;
uint_32 type, state, id, helpId;
uint_16 resInfo;
state = 0;
id = 0;
resInfo = 0;
// Store first structure members in temporary variables until
// we know whether or not the item is a MenuExItemNormal or a
// MenuExItemPopup
error = ResReadUint32( &type, handle );
if( !error ) {
error = ResReadUint32( &state, handle );
}
if( !error ) {
error = ResReadUint32( &id, handle );
}
if( !error ) {
error = ResReadUint16( &resInfo, handle );
}
// Determine if this is a normal menu item or a popup menu item
if( resInfo & MENUEX_POPUP ) {
curritem->IsPopup = true;
curritem->Item.ExPopup.Popup.ItemFlags = resInfo;
curritem->Item.ExPopup.ExData.ItemId = id;
curritem->Item.ExPopup.ExData.ItemType = type;
curritem->Item.ExPopup.ExData.ItemState = state;
curritem->Item.ExPopup.Popup.ItemText = ResRead32String( handle, NULL );
// Careful! The string is DWORD aligned.
ResPadDWord( handle );
error = ResReadUint32( &helpId, handle );
curritem->Item.ExPopup.ExData.HelpId = helpId;
} else {
curritem->IsPopup = false;
curritem->Item.ExNormal.Normal.ItemFlags = resInfo;
curritem->Item.ExNormal.Normal.ItemID = id;
curritem->Item.ExNormal.Normal.ItemText = ResRead32String( handle, NULL );
// Careful! The string is DWORD aligned.
ResPadDWord( handle );
curritem->Item.ExNormal.ExData.ItemType = type;
curritem->Item.ExNormal.ExData.ItemState = state;
}
return( error );
}
WResID *WRGetUniCodeWResID( WResFileID file_handle, uint_32 rva )
{
uint_32 old_pos;
uint_32 offset;
uint_16 len;
bool ok;
char *unistr;
WResID *id;
int i;
offset = WR_MAP_RES_RVA( rva );
unistr = NULL;
/* seek to the location of the Unicode string */
ok = ((old_pos = ResSeek( file_handle, offset, SEEK_SET )) != -1);
/* read the Unicode string */
if( ok ) {
ResReadUint16( &len, file_handle );
len *= 2;
unistr = (char *)MemAlloc( len + 2 );
ok = (unistr != NULL);
}
if( ok ) {
unistr[len] = 0;
unistr[len + 1] = 0;
ok = (read( file_handle, unistr, len ) == len);
}
if( ok ) {
for( i = 0; i < len + 2; i += 2 ) {
unistr[i / 2] = unistr[i];
}
ok = ((id = WResIDFromStr( unistr )) != NULL);
}
#if 0
if( old_pos != -1 ) {
ok = (ResSeek( file_handle, old_pos, SEEK_SET ) != -1 && ok);
}
#endif
if( unistr != NULL ) {
MemFree( unistr );
}
if( ok ) {
return( id );
} else {
return( NULL );
}
}
char *ResRead32String( WResFileID handle, int *strlen )
/*****************************************************/
{
VarString * newstring;
bool error;
uint_16 nextchar;
char * retstring;
newstring = VarStringStart();
error = ResReadUint16( &nextchar, handle );
while( !error && nextchar != 0x0000 ) {
VarStringAddChar( newstring, (uint_8)(nextchar & 0x00ff) );
error = ResReadUint16( &nextchar, handle );
}
retstring = VarStringEnd( newstring, strlen );
if( error && retstring != NULL ) {
WRESFREE(retstring);
retstring = NULL;
}
return( retstring );
} /* ResRead32String */
MResResourceHeader *MResReadResourceHeader( WResFileID handle )
/*************************************************************/
{
MResResourceHeader *newhead;
int error;
uint_16 tmp16;
uint_32 tmp32;
newhead = WRESALLOC( sizeof(MResResourceHeader) );
if( newhead == NULL ) {
error = TRUE;
WRES_ERROR( WRS_MALLOC_FAILED );
} else {
error = FALSE;
}
if (!error) {
newhead->Type = ResReadNameOrOrdinal( handle );
error = (newhead->Type == NULL);
}
if (!error) {
newhead->Name = ResReadNameOrOrdinal( handle );
error = (newhead->Name == NULL);
}
if (!error) {
error = ResReadUint16( &tmp16, handle);
newhead->MemoryFlags = tmp16;
}
if (!error) {
error = ResReadUint32( &tmp32, handle );
newhead->Size = tmp32;
}
if (error && newhead != NULL) {
WRESFREE( newhead );
newhead = NULL;
}
return( newhead );
} /* MResReadResourceHeader */
int WRLoadWResDirFromWin16EXE( WResFileID file_handle, WResDir *dir )
{
os2_exe_header win_header;
long int offset;
uint_16 align_shift;
uint_32 name_offset;
WResTypeNode *type_node;
uint_8 *name_table;
uint_8 *leftover;
uint_32 name_table_len;
uint_32 num_leftover;
int ok;
ok = (file_handle != -1);
if( ok ) {
ok = ((*dir = WResInitDir()) != NULL);
}
if( ok ) {
ok = ((offset = WRReadWin16ExeHeader( file_handle, &win_header )) != 0);
}
/* check if a resource table is present */
if( ok ) {
ok = WRWin16HeaderHasResourceTable( &win_header );
if( !ok ) {
return( TRUE );
}
}
if( ok ) {
ok = (ResSeek( file_handle, offset, SEEK_SET ) != -1);
}
if( ok ) {
ok = (ResSeek( file_handle, win_header.resource_off, SEEK_CUR ) != -1);
}
if( ok ) {
ResReadUint16( &align_shift, file_handle );
ok = (align_shift <= 16);
if( !ok ) {
WRDisplayErrorMsg( WR_BADEXE );
}
}
if( ok ) {
(*dir)->NumResources = 0;
type_node = WRReadWResTypeNodeFromExe( file_handle, align_shift );
while( type_node != NULL ) {
type_node->Next = NULL;
type_node->Prev = (*dir)->Tail;
if( (*dir)->Tail != NULL ) {
(*dir)->Tail->Next = type_node;
}
if ( (*dir)->Head == NULL ) {
(*dir)->Head = type_node;
}
(*dir)->Tail = type_node;
(*dir)->NumTypes++;
(*dir)->NumResources += type_node->Info.NumResources;
type_node = WRReadWResTypeNodeFromExe ( file_handle, align_shift );
}
name_offset = tell( file_handle ) - offset - win_header.resource_off;
ok = WRReadResourceNames( *dir, file_handle, name_offset );
}
if( ok && win_header.expver <= 0x300 ) {
num_leftover = 0;
leftover = NULL;
name_table_len = WRReadNameTable( *dir, file_handle,
&name_table, num_leftover, leftover );
while( name_table_len != 0 ) {
num_leftover = WRUseNameTable( *dir, name_table, name_table_len, &leftover );
if( name_table != NULL ) {
WRMemFree( name_table );
}
name_table_len = WRReadNameTable( NULL, file_handle, &name_table,
num_leftover, leftover );
if( leftover != NULL ) {
WRMemFree( leftover );
leftover = NULL;
}
}
}
return( ok );
}
extern M32ResResourceHeader *M32ResReadResourceHeader( WResFileID handle )
/************************************************************************/
{
M32ResResourceHeader *newhead;
int error = FALSE;
uint_16 tmp16;
uint_32 tmp32;
newhead = WRESALLOC( sizeof( M32ResResourceHeader ) );
if( newhead == NULL ) {
error = TRUE;
WRES_ERROR( WRS_MALLOC_FAILED );
}
newhead->head16 = WRESALLOC( sizeof( MResResourceHeader ) );
if( newhead->head16 == NULL ) {
error = TRUE;
WRES_ERROR( WRS_MALLOC_FAILED );
}
if( !error ) {
error = ResPadDWord( handle );
}
if( !error ) {
error = ResReadUint32( &tmp32, handle );
newhead->head16->Size = tmp32;
}
if( !error ) {
error = ResReadUint32( &(newhead->HeaderSize), handle );
}
if( !error ) {
newhead->head16->Type = ResRead32NameOrOrdinal( handle );
error = (newhead->head16->Type == NULL );
}
if( !error ) {
newhead->head16->Name = ResRead32NameOrOrdinal( handle );
error = (newhead->head16->Name == NULL );
}
if( !error ) {
error = ResPadDWord( handle );
}
if( !error ) {
error = ResReadUint32( &tmp32, handle );
newhead->head16->DataVersion = tmp32;
}
if( !error ) {
error = ResReadUint16( &tmp16, handle );
newhead->head16->MemoryFlags = tmp16;
}
if( !error ) {
error = ResReadUint16( &tmp16, handle );
newhead->head16->LanguageId = tmp16;
}
if( !error ) {
error = ResReadUint32( &tmp32, handle );
newhead->head16->Version = tmp32;
}
if( !error ) {
error = ResReadUint32( &tmp32, handle );
newhead->head16->Characteristics = tmp32;
}
if( error && newhead != NULL ) {
WRESFREE( newhead->head16 );
WRESFREE( newhead );
newhead = NULL;
}
return( newhead );
}
