/******************************************************************************
*                                                                             *
*                         EXE header list and modify                          *
*                                                                             *
*                        by Pierre Martineau, 91/01/29                        *
*                                                                             *
*                                Version 1.2                                  *
*                                                                             *
>*****************************************************************************<
* Modified (stephen@estragon.uchicago.edu):                                   *
* 1990oct23 sps Overlay splitter-outer first cut                              *
*        31     Error handling; some #defines                                 *
*     nov01     /l                                                            *
*   91jan29     Changed default overlay file names to conform to ovlmgr 30a0  *
******************************************************************************/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

/** parameters ***************************************************************/
#define MAXFILENAME 128   /* Probably overkill - theoretical limit is 80     */
#define NPARTS	    36	  /* Maximum # of overlay files (excluding root .EXE)*/
#define COPYBUFSIZE 32768 /* Fair sized buffer for file copy                 */
#define BAKEXT      ".BAK"/* Extension for .exe backups                      */
#define OVLEXT      ".OVL"/* Default extension for overlay files             */
/* #define MANYZEROES */  /* Old style default: foo00001.ovl, not foo0.ovl   */
/*****************************************************************************/

#define BOOLEAN int
#define TRUE    1
#define FALSE   0

int sstrccnt(register char const *s, register char c)
  { int n = 0;

    while (*s) if (*s++ == c) n++;
    return n;
  }

FILE *wrkfile, *outfile;
long min, max, stk;
BOOLEAN listflg = FALSE;
BOOLEAN verbose = FALSE;
BOOLEAN minflg = FALSE;
BOOLEAN maxflg = FALSE;
BOOLEAN stkflg = FALSE;

int column = 0;

struct exehdr {
unsigned signature;
unsigned mod512;
unsigned pages;
unsigned relocitems;
unsigned headerparas;
unsigned minalloc;
unsigned maxalloc;
unsigned ss;
unsigned sp;
unsigned checksum;
unsigned ip;
unsigned cs;
unsigned relocptr;
unsigned ovlnum;
} exehdr_area;

main(argc, argv)
int argc;
char *argv[];
{
char *dot, *slash;
char fname[MAXFILENAME], oname[MAXFILENAME], zname[MAXFILENAME];
char *jname = NULL;
char *args;
int i;
long offset, oldstk;
unsigned nparts = 0, part = 0, partstart[NPARTS + 2];

    printf("EXE list and modify V1.1s, by Pierre Martineau, 90/05/20.\n");
    printf("This program may be freely distributed.\n");

	if ((argc < 2) || (argc > NPARTS + 2)) {
        usage();
        return;
    }

/*  Process any remaining arguments  */

    if (argc == 2) {
        listflg = TRUE;
        verbose = TRUE; /* ??? */
    }
    else {
        i = 2;
        while (argc-- > 2) {
            args = argv[i];
	    if ('0' <= args[0] && args[0] <= '9') { /* File split request */
			if (nparts >= NPARTS) {
			printf("\nToo many .OVL files requested (max. %d)\n", NPARTS);
		    usage();
		    return;
		}
		else if (!atoi(args)) {
		    printf("\nCan't relocate the root overlay (#0)\n");
		    usage();
		    return;
		}
		else if (nparts && partstart[nparts - 1] >= atoi(args)) {
		    printf("\nOverlay starts must be in ascending order\n");
		    usage();
		    return;
		}
		partstart[nparts++] = atoi(args);
	    } else {
		if ((args[0] != '-') && (args[0] != '/')) {
		    printf("\nInvalid switch in paramater %s!\n", argv[i]);
			usage();
			return;
		}
		args++;
		if (strnicmp(args, "min", 3) == 0) {
		    args += 3;
		    min = atol(args);
		    minflg = TRUE;
		}
		else if (strnicmp(args, "max", 3) == 0) {
		    args += 3;
		    max = atol(args);
		    maxflg = TRUE;
		}
		else if (strnicmp(args, "stk", 3) == 0) {
		    args += 3;
		    stk = atol(args);
		    stkflg = TRUE;
		}
		else if (strnicmp(args, "v", 1) == 0) {
		    listflg = TRUE;
                    verbose = TRUE;
                }
                else if (strnicmp(args, "l", 1) == 0)
                    listflg = TRUE;
                else if (strnicmp(args, "p", 1) == 0) {
                    args++;
                    jname = args;
                }
		else {
		    printf("\nInvalid paramater %s!\n", argv[i]);
		    usage();
		    return;
		}
            }
            i++;
        }
    }

/*  Extract filename from first argumemt  */

    strcpy(fname, argv[1]);
    dot = strrchr(fname, '.');
    slash = strrchr(fname, '\\');
    if ((dot == NULL) || (slash > dot))
        strcat(fname, ".exe");

    if (nparts) {
	strcpy(oname,fname);
	*strrchr(fname, '.') = '\0';
	strcat(fname,BAKEXT);
	if (!stricmp(oname,fname)) {
	    printf(
                "\nI refuse to split a file with extension "BAKEXT": %s\n",
                oname
            );
	    return;
	}
        if (!jname || nparts > 1 && !sstrccnt(jname, '?')) {
            char ext[5];
            char *t;

            if (!jname) {
                strcpy(zname, oname);
                *strrchr(zname, '.') = '\0';
                strcpy(ext, OVLEXT);
            } else {
                if (strrchr(jname, '.') &&
                     (!strrchr(jname, '\\') ||
                         strrchr(jname, '.') > strrchr(jname, '\\')
                     )
                ) {
                    strncpy(ext, strrchr(jname, '.'), sizeof(ext));
                    ext[sizeof(ext) - 1] = '\0';
                    strncpy(zname, jname, strrchr(jname, '.') - jname);
                    zname[strrchr(jname, '.') - jname] = '\0';
                } else {
                    strcpy(zname, jname);
                    strcpy(ext, OVLEXT);
                }
            }
            t = strrchr(zname, '\\') ? strrchr(zname, '\\') + 1:
                strrchr(zname, ':') ? strrchr(zname, ':') + 1:
                zname;
            if (strlen(t) >= 8)
                t[7] = '\0';
#if defined(MANYZEROES)
	    while (strlen(t) < 8)
#endif
	      strcat(t, "?");
            strcat(zname, ext);
            jname = zname;
        }
	if (rename(oname,fname)) { /* This assumes oldname, newname.
				      There's some confusion. OK for TC2.0 */
	    printf("\nCouldn't rename (original) %s to %s\n", oname, fname);
	    return;
	}
	if ((outfile = fopen(oname, "wb")) == NULL) {
            printf("\nCouldn't create file %s\n",oname);
            return;
        }
    }

    if ((wrkfile = fopen(fname, "r+b")) == NULL) {
        printf("\nCouldn't open file %s\n", fname);
        return;
    }

    fread(&exehdr_area, sizeof (struct exehdr), 1, wrkfile);
    if (exehdr_area.signature != 0x5a4d) {
        printf("\nNot an EXE file!\n");
        return;
    }

    while(!feof(wrkfile)) {
        if (nparts) {
	    if (exehdr_area.ovlnum == partstart[part]) {
	         fclose(outfile);
                 {
                     int p = part + 1;
                     strcpy(oname, jname);
                     while (sstrccnt(oname, '?') > 1) {
                         *strrchr(oname, '?') = '0' + p % 10;
                         p /= 10;
                     }
                     *strchr(oname, '?') = (p > 9 ? 'a' - 10 : '0') + p;
                 }
                 part++;
		 if ((outfile = fopen(oname, "wb")) == NULL) {
                     printf("\nCan't open file %s\n", oname);
                     return;
                 }
	    }
            fwrite(&exehdr_area, sizeof (struct exehdr), 1, outfile);
            if (ferror(outfile)) {
                printf("\nWrite error while moving overlay header in %s\n", oname);
                return;
            }
	}
        if (listflg)
            show_hdr();
        else if (nparts)
            printf("[overlay %d]\r", exehdr_area.ovlnum); /* Keep talking... */
        if ((minflg || maxflg || stkflg) && (exehdr_area.ovlnum == 0) && (exehdr_area.signature == 0x5a4d)) {
            if (minflg)
                exehdr_area.minalloc = min;
            if (maxflg)
                exehdr_area.maxalloc = max;
            if (stkflg) {
                oldstk = exehdr_area.sp;
                exehdr_area.sp = stk;
                if (!minflg) {
                    exehdr_area.minalloc += ((stk - oldstk) / 16);
                    printf("\nAdjusting size of minalloc!\n");
                }
            }
            fseek(nparts ? outfile : wrkfile, ftell(wrkfile) - sizeof (struct exehdr), SEEK_SET);
            fwrite(&exehdr_area, sizeof (struct exehdr), 1, nparts ? outfile : wrkfile);
            if (ferror(nparts ? outfile : wrkfile)) {
                printf("Write error while trying to update header!\n");
                fclose(nparts ? outfile : wrkfile);
                return;
            }
        }
        offset = exehdr_area.pages;
        offset *= 512L;
        offset -= sizeof(struct exehdr);
        if (nparts) { /* Copy the stuff across */
	    static char buffer[COPYBUFSIZE];
	    while (offset > sizeof(buffer)) {
	         fread(buffer, sizeof(buffer), 1, wrkfile);
                 if (ferror(wrkfile)) {
                     printf("\nRead error in overlay body\n");
                     return;
                 }
		 fwrite(buffer, sizeof(buffer), 1, outfile);
                 if (ferror(outfile)) {
                     printf("\nWrite error moving overlay body, file %s\n", oname);
                     return;
                 }
		 offset -= sizeof(buffer);
	    }
	    fread(buffer, (unsigned)offset, 1, wrkfile);
            if (ferror(wrkfile)) {
                printf("\nRead error in overlay body\n");
                return;
            }
            fwrite(buffer, (unsigned)offset, 1, outfile);
            if (ferror(outfile)) {
                printf("\nWrite error moving overlay body, file %s\n", oname);
                return;
            }
        } else fseek(wrkfile, offset, SEEK_CUR);
        fread(&exehdr_area, sizeof (struct exehdr), 1, wrkfile);
        if (ferror(wrkfile)) {
            printf("Read error while trying to get a header!\n");
            fclose(wrkfile);
            return;
        }
    }
    if (nparts) {
        fclose(outfile);
        if (!listflg) printf("                    \r");
    }
    fclose(wrkfile);
    if (listflg && !verbose && column % 4) printf("\n");
}

show_hdr()
{
long lsize;

    lsize = exehdr_area.pages;
    if (exehdr_area.mod512 != 0)
        lsize--;
    lsize *= 512L;
    lsize += exehdr_area.minalloc * 16;
    lsize += exehdr_area.mod512;
    lsize -= exehdr_area.headerparas * 16;

    if (verbose) {
        printf("\nOverlay: %d\n", exehdr_area.ovlnum);
        printf("Size (512 byte pages)\t-%6x\t\t%6u\n", exehdr_area.pages, exehdr_area.pages);
        printf("Remainder (last page)\t-%6x\t\t%6u\n", exehdr_area.mod512, exehdr_area.mod512);
        printf("Header size (in paras)\t-%6x\t\t%6u\n", exehdr_area.headerparas, exehdr_area.headerparas);
        printf("Minalloc (in paras)\t-%6x\t\t%6u\n", exehdr_area.minalloc, exehdr_area.minalloc);
        printf("Maxalloc (in paras)\t-%6x\t\t%6u\n", exehdr_area.maxalloc, exehdr_area.maxalloc);
        printf("Load size (in bytes)\t-%6lx\t\t%6lu\n", lsize, lsize);
        printf("Relocation items\t-%6x\t\t%6u\n", exehdr_area.relocitems, exehdr_area.relocitems);
        printf("Relocation table offset\t-%6x\t\t%6u\n", exehdr_area.relocptr, exehdr_area.relocptr);
        printf("Checksum\t\t-%6x\t\t%6u\n", exehdr_area.checksum, exehdr_area.checksum);
        printf("Initial CS:IP\t\t-  %04x:%04x\n", exehdr_area.cs, exehdr_area.ip);
        printf("Initial SS:SP\t\t-  %04x:%04x\n", exehdr_area.ss, exehdr_area.sp);
    } else {
        if (!exehdr_area.ovlnum) {
            printf("\nOverlay: %d\n", exehdr_area.ovlnum);
            printf("Minalloc (in paras)\t-%6x\t\t%6u\n", exehdr_area.minalloc, exehdr_area.minalloc);
            printf("Maxalloc (in paras)\t-%6x\t\t%6u\n", exehdr_area.maxalloc, exehdr_area.maxalloc);
            printf("Stored size (in bytes)\t-%6lx\t\t%6lu\n", exehdr_area.pages * 512L, exehdr_area.pages * 512L);
            printf("Load size (in bytes)\t-%6lx\t\t%6lu\n", lsize, lsize);
            printf("Initial CS:IP, SS:SP\t-  %04x:%04x\t  %04x:%04x\n", exehdr_area.cs, exehdr_area.ip, exehdr_area.ss, exehdr_area.sp);
	} else {
	    static bis = 0;
	    if (!bis++)
                printf("\nOvl StrdSz LoadSz | Ovl StrdSz LoadSz | Ovl StrdSz LoadSz | Ovl StrdSz LoadSz\n");
            printf("%3d:%6lu %6lu%s", exehdr_area.ovlnum, exehdr_area.pages * 512L, lsize, ++column % 4 ? " | " : "\n");
        }
    }
}

usage()
{
    printf("\nUsage: exesmurf exe_file [/l] [/v] [/min#####] [/max#####] [/stk#####]\n");
    printf("                [n1 n2...nn] [/p????????.???]\n");
    printf("       where: min   = minalloc\n");
    printf("              max   = maxalloc\n");
    printf("              stk   = stack size\n");
    printf("              ##### = decimal number of paragraphs\n");
    printf("              ni    = overlay starting each new .OVL file, n1 < n2 <...< nn\n");
    printf("              p     = DOS filename, maybe with ?s, for overlay files.\n");
}