Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // pe2kos.cpp : Defines the entry point for the console application.
  2. //
  3.  
  4. //#define TARGET_USES_PATH
  5.  
  6. #include <string.h>
  7. #include <stdio.h>
  8. #include <io.h>
  9.  
  10. typedef unsigned __int32 DWORD;
  11. typedef unsigned __int16 WORD;
  12. typedef unsigned __int8 BYTE;
  13.  
  14. #pragma pack(1)
  15.  
  16. struct kos_Header
  17. {
  18.         char kosSign[8];
  19.         DWORD res1;
  20.         DWORD start;
  21.         DWORD end;
  22.         DWORD memory;
  23.         DWORD stack;
  24.         DWORD res2;
  25.         DWORD res3;
  26.         //
  27.         kos_Header()
  28.         {
  29.                 memcpy( kosSign, "MENUET01", 8 );
  30.                 res1 = 1;
  31.                 res2 = 0;
  32.                 res3 = 0;
  33.         }
  34. };
  35.  
  36.  
  37. void load_section( BYTE *pePtr, BYTE *secDescPtr, FILE *fp )
  38. {
  39.         DWORD *dwPtr = (DWORD *)secDescPtr;
  40.         DWORD virtualSize;
  41.  
  42.         //
  43.         virtualSize = ( dwPtr[2] >= dwPtr[4] ) ? dwPtr[2] : dwPtr[4];
  44.         //
  45.         fseek( fp, dwPtr[3], SEEK_SET );
  46.         fwrite( pePtr + dwPtr[5], virtualSize, 1, fp );
  47. }
  48.  
  49.  
  50. int main(int argc, char* argv[])
  51. {
  52.         FILE *pe, *kos;
  53.         kos_Header hdr;
  54.         BYTE *peBuff;
  55.         BYTE *scanPtr;
  56.         long peSize;
  57.         DWORD baseNdx;
  58.         WORD sCount, sLim;
  59.  
  60.         //
  61.         if ( argc != 3 ) return 0;
  62.  
  63.         //
  64.         pe = fopen( argv[1], "rb" );
  65.         if ( pe == NULL ) return 0;
  66.         //
  67.         kos = fopen( argv[2], "w+b" );
  68.         if ( kos == NULL )
  69.         {
  70.                 fclose( pe );
  71.                 return 0;
  72.         }
  73.         //
  74.         fseek( pe, 0, SEEK_END );
  75.         peSize = ftell( pe );
  76.         fseek( pe, 0, SEEK_SET );
  77.         //
  78.         peBuff = new BYTE[peSize];
  79.         fread( peBuff, peSize, 1, pe );
  80.         fclose( pe );
  81.         //
  82.         //
  83.         scanPtr = peBuff + ((DWORD *)(peBuff + 0x3C))[0];
  84.         //
  85.         baseNdx = 0xF8;
  86.         //
  87.         sLim = ((WORD *)(scanPtr + 6))[0];
  88.         //
  89.         for ( sCount = 0; sCount < sLim; sCount++ )
  90.         {
  91.                 //
  92.                 switch ( scanPtr[baseNdx + 0x24] )
  93.                 {
  94.                 //
  95.                 case 0x20:
  96.                 case 0x40:
  97.                         load_section( peBuff, scanPtr + baseNdx, kos );
  98.                         break;
  99.                 //
  100.                 default:
  101.                         break;
  102.                 }
  103.                 //
  104.                 baseNdx += 0x28;
  105.  
  106.         }
  107.         //
  108.         fseek( kos, 0, SEEK_END );
  109.         fflush(kos);
  110.         peSize = ftell( kos );
  111.         for (;;)
  112.         {
  113.                 fseek(kos, -1, SEEK_CUR);
  114.                 if (fgetc(kos))
  115.                         break;
  116.                 fseek(kos, -1, SEEK_CUR);
  117.         }
  118.         _chsize(_fileno(kos), ftell(kos));
  119.         //
  120.         hdr.start = ((DWORD *)(scanPtr + 0x28))[0];
  121.         hdr.end = ftell(kos);
  122.         hdr.stack = peSize + 4096;
  123. #ifdef TARGET_USES_PATH
  124.         hdr.res3 = hdr.stack;
  125.         hdr.memory = hdr.res3 + 2048;
  126. #else
  127.         hdr.memory = hdr.stack;
  128. #endif
  129.         //
  130.         fseek( kos, 0, SEEK_SET );
  131.         fwrite( &hdr, sizeof(hdr), 1, kos );
  132.  
  133.         //
  134.         delete [] peBuff;
  135.         //
  136.         fclose( kos );
  137.  
  138.         return 0;
  139. }
  140.