bool DumpIconGroup( uint_32 offset, uint_32 length, FILE *fp )
/************************************************************/
{
IconCurDirHeader head;
IconDirEntry entry;
bool error;
int currentry;
length = length;
RESSEEK( fp, offset, SEEK_SET );
error = ResReadIconCurDirHeader( &(head), fp );
PrintIconCurDirHeader( &head );
for( currentry = 0; !error && currentry < head.ResCount; currentry++ ) {
error = ResReadIconDirEntry( &entry, fp );
if( !error ) {
PrintIconDirEntry( &entry, currentry + 1 );
}
}
RESSEEK( fp, offset, SEEK_SET );
return( error );
}
bool WRCopyResFromFileToFile( WResFileID src_fid, uint_32 offset, uint_32 length, WResFileID dst_fid )
{
uint_32 size;
uint_8 *buf;
bool ok;
size = 0;
buf = NULL;
ok = (src_fid != WRES_NIL_HANDLE && dst_fid != WRES_NIL_HANDLE);
ok = (ok && (buf = (uint_8 *)MemAlloc( CHUNK_SIZE )) != NULL);
ok = (ok && RESSEEK( src_fid, offset, SEEK_SET ) != -1);
while( ok && length - size > CHUNK_SIZE ) {
ok = ok && WRReadResData( src_fid, (BYTE *)buf, CHUNK_SIZE );
ok = ok && WRWriteResData( dst_fid, (BYTE *)buf, CHUNK_SIZE );
size += CHUNK_SIZE;
}
ok = ok && WRReadResData( src_fid, (BYTE *)buf, length - size );
ok = ok && WRWriteResData( dst_fid, (BYTE *)buf, length - size );
if( buf != NULL ) {
MemFree( buf );
}
return( ok );
}
static void * readString( FILE *fp, long offset, ReadStrErrInfo *err )
/********************************************************************/
{
char *retstr;
if( RESSEEK( fp, offset, SEEK_SET ) ) {
err->status = RS_READ_ERROR;
err->err_code = errno;
return( NULL );
} else {
retstr = ResReadString( fp, NULL );
if( retstr == NULL ) {
if( LastWresStatus() == WRS_READ_INCOMPLETE ) {
err->status = RS_READ_INCMPLT;
} else {
err->status = RS_READ_ERROR;
err->err_code = LastWresErr();
}
return( NULL );
} else {
return( retstr );
}
}
}
static bool ChangeTmpToOutFile( FILE *tmpfile, const char *out_name )
/*******************************************************************/
{
RcStatus status; /* error while deleting or renaming */
FILE *outfile;
size_t numread;
char *buffer;
buffer = RESALLOC( BUFFER_SIZE );
status = RS_OK;
RESSEEK( tmpfile, 0, SEEK_SET );
outfile = ResOpenFileRW( out_name );
while( (numread = RESREAD( tmpfile, buffer, BUFFER_SIZE )) != 0 ) {
if( numread != BUFFER_SIZE && RESIOERR( tmpfile, numread ) ) {
status = RS_READ_ERROR;
break;
}
if( RESWRITE( outfile, buffer, numread ) != numread ) {
status = RS_WRITE_ERROR;
break;
}
}
ResCloseFile( outfile );
RESFREE( buffer );
return( status == RS_OK );
} /* ChangeTmpToOutFile */
static bool ConvertMResources( FILE *in_fp, FILE *out_fp, WResDir outdir )
/************************************************************************/
{
MResResourceHeader * mheader;
WResID * name;
WResID * type;
bool error;
bool lastheader; /* true if lastheader has been read */
uint_32 offset;
bool duplicate;
mheader = MResReadResourceHeader( in_fp );
/* assume that any error reading here means end of file */
lastheader = ( mheader == NULL );
error = false;
while( !lastheader && !error ) {
name = ConvertNameOrOrdToID( mheader->Name );
type = ConvertNameOrOrdToID( mheader->Type );
offset = RESTELL( out_fp );
/* copy the resource if it isn't a name table or if the user */
/* requested that name tables be copied */
if( type->IsName || type->ID.Num != RESOURCE2INT( RT_NAMETABLE ) ||
CmdLineParms.KeepNameTable ) {
error = WResAddResource( type, name, mheader->MemoryFlags, offset,
mheader->Size, outdir, NULL, &duplicate );
if( duplicate ) {
/* print message and continue */
puts( "Error: duplicate entry" );
error = false;
} else {
error = BinaryCopy( in_fp, out_fp, mheader->Size );
}
} else {
RESSEEK( in_fp, mheader->Size, SEEK_CUR );
}
WResIDFree( name );
WResIDFree( type );
MResFreeResourceHeader( mheader );
mheader = MResReadResourceHeader( in_fp );
/* assume that any error reading here means end of file */
lastheader = ( mheader == NULL );
}
return( error );
} /* ConvertMResources */
static RcStatus copyOneCursor( const CurFileDirEntry *entry, WResFileID fid,
void *buffer, unsigned buffer_size, BitmapInfoHeader *dibhead,
int *err_code )
/*****************************************************************************/
/* NOTE: this routine fills in dibhead as it copies the data */
{
RcStatus ret;
WResFileOffset curpos;
ret = RS_OK;
if( RESSEEK( fid, entry->Offset, SEEK_SET ) == -1 ) {
ret = RS_READ_ERROR;
*err_code = errno;
}
if( ret == RS_OK ) {
ret = ReadBitmapInfoHeader( dibhead, fid );
*err_code = errno;
}
if( ret == RS_OK ) {
if( ResWriteBitmapInfoHeader( dibhead, CurrResFile.fid ) ) {
ret = RS_WRITE_ERROR;
*err_code = LastWresErr();
}
}
if( ret == RS_OK ) {
curpos = RESTELL( fid );
if( curpos == -1 ) {
ret = RS_READ_ERROR;
*err_code = errno;
} else {
ret = CopyData( curpos,
entry->Length - sizeof(BitmapInfoHeader),
fid, buffer, buffer_size, err_code );
}
}
return( ret );
}
RcStatus SemCopyDataUntilEOF( WResFileOffset offset, WResFileID fid,
void *buff, unsigned buffsize, int *err_code )
/*********************************************************************/
{
WResFileSSize numread;
if( RESSEEK( fid, offset, SEEK_SET ) == -1 ) {
*err_code = errno;
return( RS_READ_ERROR );
}
while( (numread = RESREAD( fid, buff, buffsize )) != 0 ) {
if( RESIOERR( fid, numread ) ) {
*err_code = errno;
return( RS_READ_ERROR );
}
if( RESWRITE( CurrResFile.fid, buff, numread ) != numread ) {
*err_code = errno;
return( RS_WRITE_ERROR );
}
}
return( RS_OK );
}
static bool openExeFileInfoRO( const char *filename, ExeFileInfo *info )
/**********************************************************************/
{
RcStatus status;
exe_pe_header *pehdr;
info->fp = ResOpenFileRO( filename );
if( info->fp == NULL ) {
RcError( ERR_CANT_OPEN_FILE, filename, strerror( errno ) );
return( false );
}
info->IsOpen = true;
info->Type = FindNEPELXHeader( info->fp, &info->WinHeadOffset );
info->name = filename;
switch( info->Type ) {
case EXE_TYPE_NE_WIN:
case EXE_TYPE_NE_OS2:
status = SeekRead( info->fp, info->WinHeadOffset, &info->u.NEInfo.WinHead, sizeof( os2_exe_header ) );
if( status != RS_OK ) {
RcError( ERR_NOT_VALID_EXE, filename );
return( false );
} else {
info->DebugOffset = info->WinHeadOffset + sizeof( os2_exe_header );
}
break;
case EXE_TYPE_PE:
pehdr = &info->u.PEInfo.WinHeadData;
info->u.PEInfo.WinHead = pehdr;
status = SeekRead( info->fp, info->WinHeadOffset, &PE32( *pehdr ), sizeof( pe_header ) );
if( status != RS_OK ) {
RcError( ERR_NOT_VALID_EXE, filename );
return( false );
}
if( IS_PE64( *pehdr ) ) {
status = SeekRead( info->fp, info->WinHeadOffset, &PE64( *pehdr ), sizeof( pe_header64 ) );
if( status != RS_OK ) {
RcError( ERR_NOT_VALID_EXE, filename );
return( false );
}
info->DebugOffset = info->WinHeadOffset + sizeof( pe_header64 );
} else {
info->DebugOffset = info->WinHeadOffset + sizeof( pe_header );
}
break;
case EXE_TYPE_LX:
status = SeekRead( info->fp, info->WinHeadOffset, &info->u.LXInfo.OS2Head, sizeof( os2_flat_header ) );
if( status != RS_OK ) {
RcError( ERR_NOT_VALID_EXE, filename );
return( false );
} else {
info->DebugOffset = info->WinHeadOffset + sizeof( os2_flat_header );
}
break;
default:
RcError( ERR_NOT_VALID_EXE, filename );
return( false );
break;
}
return( !RESSEEK( info->fp, 0, SEEK_SET ) );
} /* openExeFileInfoRO */