FreeDOS/utils/exeflat.c

/****************************************************************/
/*                                                              */
/*                          exeflat.c                           */
/*                                                              */
/*                 EXE flattening program                       */
/*                                                              */
/*                      Copyright (c) 2001                      */
/*                      Bart E. Oldeman                         */
/*                      All Rights Reserved                     */
/*                                                              */
/* This file is part of DOS-C.                                  */
/*                                                              */
/* DOS-C is free software; you can redistribute it and/or       */
/* modify it under the terms of the GNU General Public License  */
/* as published by the Free Software Foundation; either version */
/* 2, or (at your option) any later version.                    */
/*                                                              */
/* DOS-C is distributed in the hope that it will be useful, but */
/* WITHOUT ANY WARRANTY; without even the implied warranty of   */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See    */
/* the GNU General Public License for more details.             */
/*                                                              */
/* You should have received a copy of the GNU General Public    */
/* License along with DOS-C; see the file COPYING.  If not,     */
/* write to the Free Software Foundation, 675 Mass Ave,         */
/* Cambridge, MA 02139, USA.                                    */
/****************************************************************/

/*

Usage: exeflat (src.exe) (dest.sys) (relocation-factor)

large portions copied from task.c

*/

/* history

	10/??/01 - Bart Oldeman 
		primary release

	11/28/01 - tom ehlert 	
		added -UPX option to make the kernel compressable with UPX

*/

#include "portab.h"
#include "exe.h"
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#define BUFSIZE 32768u

#define LENGTH(x) (sizeof(x)/sizeof(x[0]))

typedef struct {
  UWORD off, seg;
} farptr;

int compReloc(const void *p1, const void *p2)
{
  farptr *r1 = (farptr *) p1;
  farptr *r2 = (farptr *) p2;
  if (r1->seg > r2->seg)
    return 1;
  if (r1->seg < r2->seg)
    return -1;
  if (r1->off > r2->off)
    return 1;
  if (r1->off < r2->off)
    return -1;
  return 0;
}

void usage()
{
  printf("usage: exeflat (src.exe) (dest.sys) (relocation-factor)\n");
  printf
      ("               -S10   - Silent relocate segment 10 (down list)\n");
  
  exit(1);
}

int main(int argc, char **argv)
{
  exe_header header;
  int i, j;
  size_t bufsize;
  farptr *reloc;
  UWORD start_seg;
  ULONG size, to_xfer;
  UBYTE **buffers;
  UBYTE **curbuf;
  FILE *src, *dest;
  short silentSegments[20], silentcount = 0, silentdone = 0;
  int UPX = FALSE;

  /* do optional argument processing here */
  for (i = 4; i < argc; i++)
  {
    char *argptr = argv[i];
    
    if (argptr[0] != '-' && argptr[0] != '/')
      usage();
    
    argptr++;

    switch (toupper(argptr[0]))
    {
      case 'U':
        UPX = TRUE;
        break;
      case 'S':
        if (silentcount >= LENGTH(silentSegments))
        {
          printf("can't handle more then %d silent's\n",
                 LENGTH(silentSegments));
          exit(1);
        }
	
        silentSegments[silentcount++] = strtol(argptr + 1, NULL, 0);
        break;
	
      default:
        usage();
    }
  }

  /* arguments left :
     infile outfile relocation offset */
  
  if ((src = fopen(argv[1], "rb")) == NULL)
  {
    printf("Source file %s could not be opened\n", argv[1]);
    return 1;
  }
  if (fread(&header, sizeof(header), 1, src) != 1)
  {
    printf("Error reading header from %s\n", argv[1]);
    fclose(src);
    return 1;
  }
  if (header.exSignature != MAGIC)
  {
    printf("Source file %s is not a valid .EXE\n", argv[1]);
    fclose(src);
    return 1;
  }
  if ((dest = fopen(argv[2], "wb+")) == NULL)
  {
    printf("Destination file %s could not be created\n", argv[2]);
    return 1;
  }
  start_seg = strtol(argv[3], NULL, 0);
  printf("header len = %lu = 0x%lx\n", header.exHeaderSize * 16UL,
         header.exHeaderSize * 16UL);
  size =
      ((DWORD) (header.exPages - 1) << 9) + header.exExtraBytes -
      header.exHeaderSize * 16UL;
  printf("image size (less header) = %lu = 0x%lx\n", size, size);
  printf("first relocation offset = %u = 0x%u\n", header.exOverlay,
         header.exOverlay);

  /* first read file into memory chunks */
  fseek(src, header.exHeaderSize * 16UL, SEEK_SET);
  buffers = malloc((size + BUFSIZE - 1) / BUFSIZE * sizeof(char *));
  if (buffers == NULL)
  {
    printf("Allocation error\n");
    return 1;
  }
  bufsize = BUFSIZE;
  for (to_xfer = size, curbuf = buffers; to_xfer > 0;
       to_xfer -= bufsize, curbuf++)
  {
    if (to_xfer < BUFSIZE)
      bufsize = to_xfer;
    *curbuf = malloc(bufsize);
    if (*curbuf == NULL)
    {
      printf("Allocation error\n");
      return 1;
    }
    if (fread(*curbuf, sizeof(char), bufsize, src) != bufsize)
    {
      printf("Source file read error %ld %d\n", to_xfer, bufsize);
      return 1;
    }
  }
  fseek(src, header.exRelocTable, SEEK_SET);
  reloc = malloc(header.exRelocItems * sizeof(farptr));
  if (reloc == NULL)
  {
    printf("Allocation error\n");
    return 1;
  }
  if (fread(reloc, sizeof(farptr), header.exRelocItems, src) !=
      header.exRelocItems)
  {
    printf("Source file read error\n");
    return 1;
  }
  fclose(src);
  qsort(reloc, header.exRelocItems, sizeof(reloc[0]), compReloc);
  for (i = 0; i < header.exRelocItems; i++)
  {
    ULONG spot = ((ULONG) reloc[i].seg << 4) + reloc[i].off;
    UBYTE *spot0 = &buffers[spot / BUFSIZE][spot % BUFSIZE];
    UBYTE *spot1 = &buffers[(spot + 1) / BUFSIZE][(spot + 1) % BUFSIZE];
    UWORD segment = ((UWORD) * spot1 << 8) + *spot0;
    
    for (j = 0; j < silentcount; j++)
      if (segment == silentSegments[j])
      {
        silentdone++;
        goto dontPrint;
      }
    
    printf("relocation at 0x%04x:0x%04x ->%04x\n", reloc[i].seg,
           reloc[i].off, segment);
    
  dontPrint:
    
    segment += start_seg;
    *spot0 = segment & 0xff;
    *spot1 = segment >> 8;
  }
  
  if (UPX)
  {
    /* UPX HEADER jump $+2+size */
    static char JumpBehindCode[] = {
      /* kernel config header - 32 bytes */
      0xeb, 0x1b,               /*     jmp short realentry */
      'C', 'O', 'N', 'F', 'I', 'G', 32 - 2 - 6 - 2 - 3, 0,      /* WORD */
      0,                        /* DLASortByDriveNo            db 0  */
      1,                        /* InitDiskShowDriveAssignment db 1  */
      2,                        /* SkipConfigSeconds           db 2  */
      0,                        /* ForceLBA                    db 0  */
      1,                        /* GlobalEnableLBAsupport      db 1  */
      'u', 'n', 'u', 's', 'e', 'd',     /* unused filler bytes                              */
      8, 7, 6, 5, 4, 3, 2, 1,
      /* real-entry: jump over the 'real' image do the trailer */
      0xe9, 0, 0                /* 100: jmp 103 */
    };
    
    struct x {
      char y[sizeof(JumpBehindCode) == 0x20 ? 1 : -1];
    };
    
    if (size >= 0xfe00u)
    {
      printf("kernel; size too large - must be <= 0xfe00\n");
      exit(1);
    }

    /* this assumes <= 0xfe00 code in kernel */
    *(short *)&JumpBehindCode[0x1e] += size;
    fwrite(JumpBehindCode, 1, 0x20, dest);
  }

  /* write dest file from memory chunks */
  bufsize = BUFSIZE;
  for (to_xfer = size, curbuf = buffers; to_xfer > 0;
       to_xfer -= bufsize, curbuf++)
  {
    if (to_xfer < BUFSIZE)
      bufsize = to_xfer;
    if (fwrite(*curbuf, sizeof(char), bufsize, dest) != bufsize)

    {
      printf("Destination file write error\n");
      return 1;
    }
  }
 
  if (UPX)
  {
    /* UPX trailer */
    /* hand assembled - so this reamins ANSI C ;-)  */
    static char trailer[] = {   /* shift down everything by sizeof JumpBehindCode */
      0xE8, 0x00, 0x00,         /* call 103                     */
      0x59,                     /* pop cx                       */
      0x0E,                     /* push cs                      */
      0x1F,                     /* pop ds                       */
      0x8c, 0xc8,               /* mov ax,cs            */
      0x48,                     /* dec ax                       */
      0x48,                     /* dec ax                       */
      0x8e, 0xc0,               /* mov es,ax            */
      0x31, 0xFF,               /* xor di,di            */
      0xBE, 0x00, 0x00,         /* mov si,0x00              */
      0xFC,                     /* cld                          */
      0xF3, 0xA4,               /* rep movsb                */
      0x26, 0x88, 0x1e, 0x00, 0x00,     /* mov es:[0],bl    */
      0xB8, 0x00, 0x00,         /* mov ax,0000h             */
      0x8E, 0xD0,               /* mov ss,ax                */
      0xBC, 0x00, 0x00,         /* mov sp,0000h             */
      0x31, 0xC0,               /* xor ax,ax                */
      0x50,                     /* push ax                      */
      0xC3                      /* ret                          */
    };
    *(short *)&trailer[26] = start_seg + header.exInitSS;
    *(short *)&trailer[31] = header.exInitSP;
    fwrite(trailer, 1, sizeof(trailer), dest);
  }
  fclose(dest);
  printf("\nProcessed %d relocations, %d not shown\n",
         header.exRelocItems, silentdone);
  return 0;
}