initial checkout from wrc

1 files changed, 415 insertions, 0 deletions

diff --git a/util/BuildImage.c b/util/BuildImage.c
new file mode 100644
index 0000000..2124c9d
--- /dev/null
+++ b/util/BuildImage.c
@@ -0,0 +1,415 @@
+/**
+** SCCS ID:	@(#)BuildImage.c	2.2	1/16/25
+**
+** @file	BuildImage.c
+**
+** @author	K. Reek
+** @author	Jon Coles
+** @author	Warren R. Carithers
+** @author	Garrett C. Smith
+**
+** Modify the bootstrap image to include the information
+** on the programs to be loaded, and produce the file
+** that contains the concatenation of these programs.
+**
+*/
+
+#define	_POSIX_C_SOURCE	200809L
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#define	TRUE	1
+#define	FALSE	0
+
+#define	DRIVE_FLOPPY	0x00
+#define	DRIVE_USB		0x80
+
+#define	SECT_SIZE	512
+
+char *progname;				/* invocation name of this program */
+char *bootstrap_filename;	/* path of file holding bootstrap program */
+char *output_filename;		/* path of disk image file */
+FILE *out;					/* output stream for disk image file */
+short drive = DRIVE_USB;	/* boot drive */
+
+/*
+** Array into which program information will be stored, starting at the
+** end and moving back toward the front.  The array is the same size as
+** a sector, which is guaranteed to be larger than the maximum possible
+** space available for this stuff in the bootstrap image.  Thus, the
+** bootstrap image itself (and the amount of space available on the
+** device) are the only limiting factors on how many program sections
+** can be loaded.
+*/
+
+#define	N_INFO	( SECT_SIZE / sizeof( short ) )
+
+short info[ N_INFO ];
+int n_info = N_INFO;
+
+/**
+** quit with an appropriate message
+**
+** @param msg   NULL, or a message to be printed to stderr
+** @param call_perror  non-zero if perror() should be used; else,
+**                     fprintf() will be used
+**
+** does not return
+*/
+void quit( char *msg, int call_perror ) {
+	if( msg != NULL ){
+		// preserve the error code in case we need it
+		int err_num = errno;
+		fprintf( stderr, "%s: ", progname );
+		errno = err_num;
+		if( call_perror ){
+			perror( msg );
+		} else {
+			fprintf( stderr, "%s\n", msg );
+		}
+	}
+	if( output_filename != NULL ){
+		unlink( output_filename );
+	}
+	exit( EXIT_FAILURE );
+	// NOTREACHED
+}
+
+const char	usage_error_msg[] =
+  "\nUsage: %s [ -d drive ] -b bootfile -o outfile { progfile loadpt } ...\n\n"
+  "\t'drive' is either 'floppy' or 'usb' (default 'usb')\n\n"
+  "\tThere must be at least one program file and load point.\n\n"
+  "\tLoad points may be specified either as 32-bit quantities in hex,\n"
+  "\tdecimal or octal (e.g. 0x10c00, 68608, 0206000 are all equivalent),\n"
+  "\tor as an explicit segment:offset pair whose digits are always\n"
+  "\tinterpreted as hexadecimal values (e.g. 10c0:0000, 1000:0c00 are\n"
+  "\tboth equivalent to the previous examples).\n\n";
+
+/**
+** print a usage message and then call quit()
+**
+** does not return
+*/
+void usage_error( void ){
+	fprintf( stderr, usage_error_msg, progname );
+	quit( NULL, FALSE );
+	// NOTREACHED
+}
+
+/**
+** copy the contents of a binary file into the output file, padding the
+** last sector with NUL bytes
+**
+** @param in   open FILE to be read
+** @return the number of sectors copied from the file
+*/
+int copy_file( FILE *in ){
+	int n_sectors = 0;
+	char buf[ SECT_SIZE ];
+	int n_bytes;
+	int i;
+
+	/*
+	** Copy the file to the output, being careful that the
+	** last sector is padded with null bytes out to the
+	** sector size.
+	*/
+	n_sectors = 0;
+	while( (n_bytes = fread( buf, 1, sizeof( buf ), in )) > 0 ){
+		// pad this sector out to block size
+		if( n_bytes < sizeof( buf ) ){
+			int i;
+
+			for( i = n_bytes; i < sizeof( buf ); i += 1 ){
+				buf[ i ] = '\0';
+			}
+		}
+		if( fwrite( buf, 1, sizeof( buf ), out ) != sizeof( buf ) ){
+			quit( "Write failed or was wrong size", FALSE );
+		}
+		n_sectors += 1;
+	}
+	return n_sectors;
+}
+
+/**
+** process a file whose contents should be at a specific'
+** address in memory when the program is loaded
+**
+** @param name  path to the file to be copied
+** @param addr  string containing the load address
+*/
+void process_file( char *name, char *addr ){
+	long address;
+	short segment, offset;
+	int n_bytes;
+
+	/*
+	** Open the input file.
+	*/
+	FILE *in = fopen( name, "rb" );
+	if( in == NULL ){
+		quit( name, TRUE );
+	}
+
+	/*
+	** Copy the file to the output, being careful that the
+	** last block is padded with null bytes.
+	*/
+	int n_sectors = copy_file( in );
+	fclose( in );
+
+	/*
+	** Decode the address they gave us. We'll accept two forms:
+	** "nnnn:nnnn" for a segment:offset value (assumed to be hex),
+	** "nnnnnnn" for a decimal, hex, or octal value
+	*/
+	int valid_address = FALSE;
+	char *cp = strchr( addr, ':' );
+	if( cp != NULL ){
+		// must be in nnnn:nnnn form exactly
+		if( strlen( addr ) == 9 && cp == addr + 4 ){
+			char *ep1, *ep2;
+			int a1, a2;
+
+			segment = strtol( addr, &ep1, 16 );
+			offset = strtol( addr + 5, &ep2, 16 );
+			address = ( segment << 4 ) + offset;
+			valid_address = *ep1 == '\0' && *ep2 == '\0';
+		} else {
+			fprintf( stderr, "Bad address format - '%s'\n", addr );
+			quit( NULL, FALSE );
+		}
+	} else {
+		// just a number, possibly hex or octal
+		char *ep;
+
+		address = strtol( addr, &ep, 0 );
+		segment = (short)( address >> 4 );
+		offset = (short)( address & 0xf );
+		valid_address = *ep == '\0' && address <= 0x0009ffff;
+	}
+
+	if( !valid_address ){
+		fprintf( stderr, "%s: Invalid address: %s\n", progname, addr );
+		quit( NULL, FALSE );
+	}
+
+	/*
+	** Make sure the program will fit!
+	*/
+	if( address + n_sectors * SECT_SIZE > 0x0009ffff ){
+		fprintf( stderr, "Program %s too large to start at 0x%08x\n",
+		    name, (unsigned int) address );
+		quit( NULL, FALSE );
+	}
+
+	if( n_info < 3 ){
+		quit( "Too many programs!", FALSE );
+	}
+
+
+	/*
+	** Looks good: report and store the information.
+	*/
+	fprintf( stderr, "  %s: %d sectors, loaded at 0x%x\n",
+	    name, n_sectors, (unsigned int) address );
+
+	info[ --n_info ] = n_sectors;
+	info[ --n_info ] = segment;
+	info[ --n_info ] = offset;
+}
+
+/*
+** Global variables set by getopt()
+*/
+
+extern int optind, optopt;
+extern char *optarg;
+
+/**
+** process the command-line arguments
+**
+** @param ac  the count of entries in av
+** @param av  the argument vector
+*/
+void process_args( int ac, char **av ) {
+	int c;
+	
+	while( (c=getopt(ac,av,":d:o:b:")) != EOF ) {
+
+		switch( c ) {
+
+		case ':':	/* missing arg value */
+			fprintf( stderr, "missing operand after -%c\n", optopt );
+			/* FALL THROUGH */
+
+		case '?':	/* error */
+			usage_error();
+			/* NOTREACHED */
+
+		case 'b':	/* -b bootstrap_file */
+			bootstrap_filename = optarg;
+			break;
+
+		case 'd':	/* -d drive */
+			switch( *optarg ) {
+			case 'f':	drive = DRIVE_FLOPPY; break;
+			case 'u':	drive = DRIVE_USB; break;
+			default:	usage_error();
+			}
+			break;
+
+		case 'o':	/* -o output_file */
+			output_filename = optarg;
+			break;
+		
+		default:
+			usage_error();
+		
+		}
+	
+	}
+
+	if( !bootstrap_filename ) {
+		fprintf( stderr, "%s: no bootstrap file specified\n", progname );
+		exit( 2 );
+	}
+
+	if( !output_filename ) {
+		fprintf( stderr, "%s: no disk image file specified\n", progname );
+		exit( 2 );
+	}
+
+	/*
+	** Must have at least two remaining arguments (file to load, 
+	** address at which it should be loaded), and must have an
+	** even number of remaining arguments.
+	*/
+	int remain = ac - optind;
+	if( remain < 2 || (remain & 1) != 0 ) {
+		usage_error();
+	}
+
+}
+
+/**
+** build a bootable image file from one or more binary files
+**
+** usage:
+**   BuildImage [ -d drive ] -b bootfile -o outfile { binfile1 loadpt1 } ... ]
+**
+** @param ac   command-line argument count
+** @param av   command-line argument vector
+** @return EXIT_SUCCESS or EXIT_FAILURE
+*/
+int main( int ac, char **av ) {
+	FILE	*bootimage;
+	int	bootimage_size;
+	int	n_bytes, n_words;
+	short	existing_data[ N_INFO ];
+	int	i;
+	
+	/*
+	** Save the program name for error messages
+	*/
+	progname = strrchr( av[ 0 ], '/' );
+	if( progname != NULL ){
+		progname++;
+	} else {
+		progname = av[ 0 ];
+	}
+
+	/*
+	** Process arguments
+	*/
+	process_args( ac, av );
+
+	/*
+	** Open the output file
+	*/
+
+	out = fopen( output_filename, "wb+" );
+	if( out == NULL ){
+		quit( output_filename, TRUE );
+	}
+
+	/*
+	** Open the bootstrap file and copy it to the output image.
+	*/
+	bootimage = fopen( bootstrap_filename, "rb" );
+	if( bootimage == NULL ){
+		quit( bootstrap_filename, TRUE );
+	}
+
+	/*
+	** Remember the size of the bootstrap for later, as we
+	** need to patch some things into it
+	*/
+	int n_sectors = copy_file( bootimage );
+	fclose( bootimage );
+
+	bootimage_size = n_sectors * SECT_SIZE;
+	fprintf( stderr, "  %s: %d sectors\n", bootstrap_filename, n_sectors );
+
+	/*
+	** Process the programs one by one
+	*/
+	ac -= optind;
+	av += optind;
+	while( ac >= 2 ){
+		process_file( av[ 0 ], av[ 1 ] );
+		ac -= 2; av += 2;
+	}
+
+	/*
+	** Check for oddball leftover argument
+	*/
+	if( ac > 0 ){
+		usage_error();
+	}
+
+	/*
+	** Seek to where the array of module data  must begin and read
+	** what's already there.
+	*/
+	n_words = ( N_INFO - n_info );
+	n_bytes = n_words * sizeof( info[ 0 ] );
+	fseek( out, bootimage_size - n_bytes, SEEK_SET );
+	if( fread( existing_data, sizeof(info[0]), n_words, out ) != n_words ){
+		quit( "Read from boot image failed or was too short", FALSE );
+	}
+
+	/*
+	** If that space is non-zero, we have a problem
+	*/
+	for( i = 0; i < n_words; i += 1 ){
+		if( existing_data[ i ] != 0 ){
+			quit( "Too many programs to load!", FALSE );
+		}
+	}
+
+	/*
+	** We know that we're only overwriting zeros at the end of
+	** the bootstrap image, so it is ok to go ahead and do it.
+	*/
+	fseek( out, bootimage_size - n_bytes, SEEK_SET );
+	if( fwrite( info + n_info, sizeof( info[ 0 ] ), n_words, out ) != n_words ){
+		quit( "Write to boot image failed or was too short", FALSE );
+	}
+
+	/*
+	** Write the drive index to the image.
+	*/
+	fseek( out, 508, SEEK_SET );
+	fwrite( (void *)&drive, sizeof(drive), 1, out );
+
+	fclose( out );
+
+	return EXIT_SUCCESS;
+
+}