minix/boot/installboot.c

/*	installboot 3.0 - Make a device bootable	Author: Kees J. Bot
 *								21 Dec 1991
 *
 * Either make a device bootable or make an image from kernel, mm, fs, etc.
 */
#define nil 0
#define _POSIX_SOURCE	1
#define _MINIX		1
#include <stdio.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <dirent.h>
#include <a.out.h>
#include <minix/config.h>
#include <minix/const.h>
#include <minix/partition.h>
#include <minix/u64.h>
#include "rawfs.h"
#include "image.h"

#define BOOTBLOCK	0	/* Of course */
#define SECTOR_SIZE	512	/* Disk sector size. */
#define RATIO(b)	((b)/SECTOR_SIZE)
#define SIGNATURE	0xAA55	/* Boot block signature. */
#define BOOT_MAX	64	/* Absolute maximum size of secondary boot */
#define SIGPOS		510	/* Where to put signature word. */
#define PARTPOS		446	/* Offset to the partition table in a master
				 * boot block.
				 */

#define between(a, c, z)	((unsigned) ((c) - (a)) <= ((z) - (a)))
#define control(c)		between('\0', (c), '\37')

#define BOOT_BLOCK_SIZE 1024

void report(char *label)
/* installboot: label: No such file or directory */
{
	fprintf(stderr, "installboot: %s: %s\n", label, strerror(errno));
}

void fatal(char *label)
{
	report(label);
	exit(1);
}

char *basename(char *name)
/* Return the last component of name, stripping trailing slashes from name.
 * Precondition: name != "/".  If name is prefixed by a label, then the
 * label is copied to the basename too.
 */
{
	static char base[IM_NAME_MAX];
	char *p, *bp= base;

	if ((p= strchr(name, ':')) != nil) {
		while (name <= p && bp < base + IM_NAME_MAX - 1)
			*bp++ = *name++;
	}
	for (;;) {
		if ((p= strrchr(name, '/')) == nil) { p= name; break; }
		if (*++p != 0) break;
		*--p= 0;
	}
	while (*p != 0 && bp < base + IM_NAME_MAX - 1) *bp++ = *p++;
	*bp= 0;
	return base;
}

void bread(FILE *f, char *name, void *buf, size_t len)
/* Read len bytes.  Don't dare return without them. */
{
	if (len > 0 && fread(buf, len, 1, f) != 1) {
		if (ferror(f)) fatal(name);
		fprintf(stderr, "installboot: Unexpected EOF on %s\n", name);
		exit(1);
	}
}

void bwrite(FILE *f, char *name, void *buf, size_t len)
{
	if (len > 0 && fwrite(buf, len, 1, f) != 1) fatal(name);
}

long total_text= 0, total_data= 0, total_bss= 0;
int making_image= 0;

void read_header(int talk, char *proc, FILE *procf, struct image_header *ihdr)
/* Read the a.out header of a program and check it.  If procf happens to be
 * nil then the header is already in *image_hdr and need only be checked.
 */
{
	int n, big= 0;
	static int banner= 0;
	struct exec *phdr= &ihdr->process;

	if (procf == nil) {
		/* Header already present. */
		n= phdr->a_hdrlen;
	} else {
		memset(ihdr, 0, sizeof(*ihdr));

		/* Put the basename of proc in the header. */
		strncpy(ihdr->name, basename(proc), IM_NAME_MAX);

		/* Read the header. */
		n= fread(phdr, sizeof(char), A_MINHDR, procf);
		if (ferror(procf)) fatal(proc);
	}

	if (n < A_MINHDR || BADMAG(*phdr)) {
		fprintf(stderr, "installboot: %s is not an executable\n", proc);
		exit(1);
	}

	/* Get the rest of the exec header. */
	if (procf != nil) {
		bread(procf, proc, ((char *) phdr) + A_MINHDR,
						phdr->a_hdrlen - A_MINHDR);
	}

	if (talk && !banner) {
		printf("     text     data      bss      size\n");
		banner= 1;
	}

	if (talk) {
		printf(" %8ld %8ld %8ld %9ld  %s\n",
			phdr->a_text, phdr->a_data, phdr->a_bss,
			phdr->a_text + phdr->a_data + phdr->a_bss, proc);
	}
	total_text+= phdr->a_text;
	total_data+= phdr->a_data;
	total_bss+= phdr->a_bss;

	if (phdr->a_cpu == A_I8086) {
		long data= phdr->a_data + phdr->a_bss;

		if (!(phdr->a_flags & A_SEP)) data+= phdr->a_text;

		if (phdr->a_text >= 65536) big|= 1;
		if (data >= 65536) big|= 2;
	}
	if (big) {
		fprintf(stderr,
			"%s will crash, %s%s%s segment%s larger then 64K\n",
			proc,
			big & 1 ? "text" : "",
			big == 3 ? " and " : "",
			big & 2 ? "data" : "",
			big == 3 ? "s are" : " is");
	}
}

void padimage(char *image, FILE *imagef, int n)
/* Add n zeros to image to pad it to a sector boundary. */
{
	while (n > 0) {
		if (putc(0, imagef) == EOF) fatal(image);
		n--;
	}
}

#define align(n)	(((n) + ((SECTOR_SIZE) - 1)) & ~((SECTOR_SIZE) - 1))

void copyexec(char *proc, FILE *procf, char *image, FILE *imagef, long n)
/* Copy n bytes from proc to image padded to fill a sector. */
{
	int pad, c;

	/* Compute number of padding bytes. */
	pad= align(n) - n;

	while (n > 0) {
		if ((c= getc(procf)) == EOF) {
			if (ferror(procf)) fatal(proc);
			fprintf(stderr,	"installboot: premature EOF on %s\n",
									proc);
			exit(1);
		}
		if (putc(c, imagef) == EOF) fatal(image);
		n--;
	}
	padimage(image, imagef, pad);
}

void make_image(char *image, char **procv)
/* Collect a set of files in an image, each "segment" is nicely padded out
 * to SECTOR_SIZE, so it may be read from disk into memory without trickery.
 */
{
	FILE *imagef, *procf;
	char *proc, *file;
	int procn;
	struct image_header ihdr;
	struct exec phdr;
	struct stat st;

	making_image= 1;

	if ((imagef= fopen(image, "w")) == nil) fatal(image);

	for (procn= 0; (proc= *procv++) != nil; procn++) {
		/* Remove the label from the file name. */
		if ((file= strchr(proc, ':')) != nil) file++; else file= proc;

		/* Real files please, may need to seek. */
		if (stat(file, &st) < 0
			|| (errno= EISDIR, !S_ISREG(st.st_mode))
			|| (procf= fopen(file, "r")) == nil
		) fatal(proc);

		/* Read a.out header. */
		read_header(1, proc, procf, &ihdr);

		/* Scratch. */
		phdr= ihdr.process;

		/* The symbol table is always stripped off. */
		ihdr.process.a_syms= 0;
		ihdr.process.a_flags &= ~A_NSYM;

		/* Write header padded to fill a sector */
		bwrite(imagef, image, &ihdr, sizeof(ihdr));

		padimage(image, imagef, SECTOR_SIZE - sizeof(ihdr));

		/* A page aligned executable needs the header in text. */
		if (phdr.a_flags & A_PAL) {
			rewind(procf);
			phdr.a_text+= phdr.a_hdrlen;
		}

		/* Copy text and data of proc to image. */
		if (phdr.a_flags & A_SEP) {
			/* Separate I&D: pad text & data separately. */

			copyexec(proc, procf, image, imagef, phdr.a_text);
			copyexec(proc, procf, image, imagef, phdr.a_data);
		} else {
			/* Common I&D: keep text and data together. */

			copyexec(proc, procf, image, imagef,
						phdr.a_text + phdr.a_data);
		}

		/* Done with proc. */
		(void) fclose(procf);
	}
	/* Done with image. */

	if (fclose(imagef) == EOF) fatal(image);

	printf("   ------   ------   ------   -------\n");
	printf(" %8ld %8ld %8ld %9ld  total\n",
		total_text, total_data, total_bss,
		total_text + total_data + total_bss);
}

void extractexec(FILE *imagef, char *image, FILE *procf, char *proc,
						long count, off_t *alen)
/* Copy a segment of an executable.  It is padded to a sector in image. */
{
	char buf[SECTOR_SIZE];

	while (count > 0) {
		bread(imagef, image, buf, sizeof(buf));
		*alen-= sizeof(buf);

		bwrite(procf, proc, buf,
			count < sizeof(buf) ? (size_t) count : sizeof(buf));
		count-= sizeof(buf);
	}
}

void extract_image(char *image)
/* Extract the executables from an image. */
{
	FILE *imagef, *procf;
	off_t len;
	struct stat st;
	struct image_header ihdr;
	struct exec phdr;
	char buf[SECTOR_SIZE];

	if (stat(image, &st) < 0) fatal(image);

	/* Size of the image. */
	len= S_ISREG(st.st_mode) ? st.st_size : -1;

	if ((imagef= fopen(image, "r")) == nil) fatal(image);

	while (len != 0) {
		/* Extract a program, first sector is an extended header. */
		bread(imagef, image, buf, sizeof(buf));
		len-= sizeof(buf);

		memcpy(&ihdr, buf, sizeof(ihdr));
		phdr= ihdr.process;

		/* Check header. */
		read_header(1, ihdr.name, nil, &ihdr);

		if ((procf= fopen(ihdr.name, "w")) == nil) fatal(ihdr.name);

		if (phdr.a_flags & A_PAL) {
			/* A page aligned process contains a header in text. */
			phdr.a_text+= phdr.a_hdrlen;
		} else {
			bwrite(procf, ihdr.name, &ihdr.process, phdr.a_hdrlen);
		}

		/* Extract text and data segments. */
		if (phdr.a_flags & A_SEP) {
			extractexec(imagef, image, procf, ihdr.name,
						phdr.a_text, &len);
			extractexec(imagef, image, procf, ihdr.name,
						phdr.a_data, &len);
		} else {
			extractexec(imagef, image, procf, ihdr.name,
				phdr.a_text + phdr.a_data, &len);
		}

		if (fclose(procf) == EOF) fatal(ihdr.name);
	}
}

int rawfd;	/* File descriptor to open device. */
char *rawdev;	/* Name of device. */

void readblock(off_t blk, char *buf, int block_size)
/* For rawfs, so that it can read blocks. */
{
	int n;

	if (lseek(rawfd, blk * block_size, SEEK_SET) < 0
		|| (n= read(rawfd, buf, block_size)) < 0
	) fatal(rawdev);

	if (n < block_size) {
		fprintf(stderr, "installboot: Unexpected EOF on %s\n", rawdev);
		exit(1);
	}
}

void writeblock(off_t blk, char *buf, int block_size)
/* Add a function to write blocks for local use. */
{
	if (lseek(rawfd, blk * block_size, SEEK_SET) < 0
		|| write(rawfd, buf, block_size) < 0
	) fatal(rawdev);
}

int raw_install(char *file, off_t *start, off_t *len, int block_size)
/* Copy bootcode or an image to the boot device at the given absolute disk
 * block number.  This "raw" installation is used to place bootcode and
 * image on a disk without a filesystem to make a simple boot disk.  Useful
 * in automated scripts for J. Random User.
 * Note: *len == 0 when an image is read.  It is set right afterwards.
 */
{
	static char buf[_MAX_BLOCK_SIZE];	/* Nonvolatile block buffer. */
	FILE *f;
	off_t sec;
	unsigned long devsize;
	static int banner= 0;
	struct partition entry;

	/* See if the device has a maximum size. */
	devsize= -1;
	if (ioctl(rawfd, DIOCGETP, &entry) == 0) devsize= cv64ul(entry.size);

	if ((f= fopen(file, "r")) == nil) fatal(file);

	/* Copy sectors from file onto the boot device. */
	sec= *start;
	do {
		int off= sec % RATIO(BOOT_BLOCK_SIZE);

		if (fread(buf + off * SECTOR_SIZE, 1, SECTOR_SIZE, f) == 0)
			break;

		if (sec >= devsize) {
			fprintf(stderr,
			"installboot: %s can't be attached to %s\n",
				file, rawdev);
			return 0;
		}

		if (off == RATIO(BOOT_BLOCK_SIZE) - 1) writeblock(sec / RATIO(BOOT_BLOCK_SIZE), buf, BOOT_BLOCK_SIZE);
	} while (++sec != *start + *len);

	if (ferror(f)) fatal(file);
	(void) fclose(f);

	/* Write a partial block, this may be the last image. */
	if (sec % RATIO(BOOT_BLOCK_SIZE) != 0) writeblock(sec / RATIO(BOOT_BLOCK_SIZE), buf, BOOT_BLOCK_SIZE);

	if (!banner) {
		printf("  sector  length\n");
		banner= 1;
	}
	*len= sec - *start;
	printf("%8ld%8ld  %s\n", *start, *len, file);
	*start= sec;
	return 1;
}

enum howto { FS, BOOT };

void make_bootable(enum howto how, char *device, char *bootblock,
					char *bootcode, char **imagev)
/* Install bootblock on the bootsector of device with the disk addresses to
 * bootcode patched into the data segment of bootblock.  "How" tells if there
 * should or shoudn't be a file system on the disk.  The images in the imagev
 * vector are added to the end of the device.
 */
{
	char buf[_MAX_BLOCK_SIZE + 256], *adrp, *parmp;
	struct fileaddr {
		off_t	address;
		int	count;
	} bootaddr[BOOT_MAX + 1], *bap= bootaddr;
	struct exec boothdr;
	struct image_header dummy;
	struct stat st;
	ino_t ino;
	off_t sector, max_sector;
	FILE *bootf;
	off_t addr, fssize, pos, len;
	char *labels, *label, *image;
	int nolabel;
	int block_size = 0;

	/* Open device and set variables for readblock. */
	if ((rawfd= open(rawdev= device, O_RDWR)) < 0) fatal(device);

	/* Read and check the superblock. */
	fssize= r_super(&block_size);

	switch (how) {
	case FS:
		if (fssize == 0) {
			fprintf(stderr,
				"installboot: %s is not a Minix file system\n",
				device);
			exit(1);
		}
		break;
	case BOOT:
		if (fssize != 0) {
			int s;
			printf("%s contains a file system!\n", device);
			printf("Scribbling in 10 seconds");
			for (s= 0; s < 10; s++) {
				fputc('.', stdout);
				fflush(stdout);
				sleep(1);
			}
			fputc('\n', stdout);
		}
		fssize= 1;	/* Just a boot block. */
	}

	if (how == FS) {
		/* See if the boot code can be found on the file system. */
		if ((ino= r_lookup(ROOT_INO, bootcode)) == 0) {
			if (errno != ENOENT) fatal(bootcode);
		}
	} else {
		/* Boot code must be attached at the end. */
		ino= 0;
	}

	if (ino == 0) {
		/* For a raw installation, we need to copy the boot code onto
		 * the device, so we need to look at the file to be copied.
		 */
		if (stat(bootcode, &st) < 0) fatal(bootcode);

		if ((bootf= fopen(bootcode, "r")) == nil) fatal(bootcode);
	} else {
		/* Boot code is present in the file system. */
		r_stat(ino, &st);

		/* Get the header from the first block. */
		if ((addr= r_vir2abs((off_t) 0)) == 0) {
			boothdr.a_magic[0]= !A_MAGIC0;
		} else {
			readblock(addr, buf, block_size);
			memcpy(&boothdr, buf, sizeof(struct exec));
		}
		bootf= nil;
		dummy.process= boothdr;
	}
	/* See if it is an executable (read_header does the check). */
	read_header(0, bootcode, bootf, &dummy);
	boothdr= dummy.process;

	if (bootf != nil) fclose(bootf);

	/* Get all the sector addresses of the secondary boot code. */
	max_sector= (boothdr.a_hdrlen + boothdr.a_text
			+ boothdr.a_data + SECTOR_SIZE - 1) / SECTOR_SIZE;

	if (max_sector > BOOT_MAX * RATIO(block_size)) {
		fprintf(stderr, "installboot: %s is way too big\n", bootcode);
		exit(0);
	}

	/* Determine the addresses to the boot code to be patched into the
	 * boot block.
	 */
	bap->count= 0;	/* Trick to get the address recording going. */

	for (sector= 0; sector < max_sector; sector++) {
		if (ino == 0) {
			addr= fssize + (sector / RATIO(block_size));
		} else
		if ((addr= r_vir2abs(sector / RATIO(block_size))) == 0) {
			fprintf(stderr, "installboot: %s has holes!\n",
								bootcode);
			exit(1);
		}
		addr= (addr * RATIO(block_size)) + (sector % RATIO(block_size));

		/* First address of the addresses array? */
		if (bap->count == 0) bap->address= addr;

		/* Paste sectors together in a multisector read. */
		if (bap->address + bap->count == addr)
			bap->count++;
		else {
			/* New address. */
			bap++;
			bap->address= addr;
			bap->count= 1;
		}
	}
	(++bap)->count= 0;	/* No more. */

	/* Get the boot block and patch the pieces in. */
	readblock(BOOTBLOCK, buf, BOOT_BLOCK_SIZE);

	if ((bootf= fopen(bootblock, "r")) == nil) fatal(bootblock);

	read_header(0, bootblock, bootf, &dummy);
	boothdr= dummy.process;

	if (boothdr.a_text + boothdr.a_data +
					 4 * (bap - bootaddr) + 1 > PARTPOS) {
		fprintf(stderr,
	"installboot: %s + addresses to %s don't fit in the boot sector\n",
			bootblock, bootcode);
		fprintf(stderr,
		    "You can try copying/reinstalling %s to defragment it\n",
			bootcode);
		exit(1);
	}

	/* All checks out right.  Read bootblock into the boot block! */
	bread(bootf, bootblock, buf, boothdr.a_text + boothdr.a_data);
	(void) fclose(bootf);

	/* Patch the addresses in. */
	adrp= buf + (int) (boothdr.a_text + boothdr.a_data);
	for (bap= bootaddr; bap->count != 0; bap++) {
		*adrp++= bap->count;
		*adrp++= (bap->address >>  0) & 0xFF;
		*adrp++= (bap->address >>  8) & 0xFF;
		*adrp++= (bap->address >> 16) & 0xFF;
	}
	/* Zero count stops bootblock's reading loop. */
	*adrp++= 0;

	if (bap > bootaddr+1) {
		printf("%s and %d addresses to %s patched into %s\n",
			bootblock, (int)(bap - bootaddr), bootcode, device);
	}

	/* Boot block signature. */
	buf[SIGPOS+0]= (SIGNATURE >> 0) & 0xFF;
	buf[SIGPOS+1]= (SIGNATURE >> 8) & 0xFF;

	/* Sector 2 of the boot block is used for boot parameters, initially
	 * filled with null commands (newlines).  Initialize it only if
	 * necessary.
	 */
	for (parmp= buf + SECTOR_SIZE; parmp < buf + 2*SECTOR_SIZE; parmp++) {
		if (*imagev != nil || (control(*parmp) && *parmp != '\n')) {
			/* Param sector must be initialized. */
			memset(buf + SECTOR_SIZE, '\n', SECTOR_SIZE);
			break;
		}
	}

	/* Offset to the end of the file system to add boot code and images. */
	pos= fssize * RATIO(block_size);

	if (ino == 0) {
		/* Place the boot code onto the boot device. */
		len= max_sector;
		if (!raw_install(bootcode, &pos, &len, block_size)) {
			if (how == FS) {
				fprintf(stderr,
	"\t(Isn't there a copy of %s on %s that can be used?)\n",
					bootcode, device);
			}
			exit(1);
		}
	}

	parmp= buf + SECTOR_SIZE;
	nolabel= 0;

	if (how == BOOT) {
		/* A boot only disk needs to have floppies swapped. */
		strcpy(parmp,
	"trailer()echo \\nInsert the root diskette then hit RETURN\\n\\w\\c\n");
		parmp+= strlen(parmp);
	}

	while ((labels= *imagev++) != nil) {
		/* Place each kernel image on the boot device. */

		if ((image= strchr(labels, ':')) != nil)
			*image++= 0;
		else {
			if (nolabel) {
				fprintf(stderr,
			    "installboot: Only one image can be the default\n");
				exit(1);
			}
			nolabel= 1;
			image= labels;
			labels= nil;
		}
		len= 0;
		if (!raw_install(image, &pos, &len, block_size)) exit(1);

		if (labels == nil) {
			/* Let this image be the default. */
			sprintf(parmp, "image=%ld:%ld\n", pos-len, len);
			parmp+= strlen(parmp);
		}

		while (labels != nil) {
			/* Image is prefixed by a comma separated list of
			 * labels.  Define functions to select label and image.
			 */
			label= labels;
			if ((labels= strchr(labels, ',')) != nil) *labels++ = 0;

			sprintf(parmp,
		"%s(%c){label=%s;image=%ld:%ld;echo %s kernel selected;menu}\n",
				label,
				between('A', label[0], 'Z')
					? label[0]-'A'+'a' : label[0],
				label, pos-len, len, label);
			parmp+= strlen(parmp);
		}

		if (parmp > buf + block_size) {
			fprintf(stderr,
		"installboot: Out of parameter space, too many images\n");
			exit(1);
		}
	}
	/* Install boot block. */
	writeblock((off_t) BOOTBLOCK, buf, 1024);

	if (pos > fssize * RATIO(block_size)) {
		/* Tell the total size of the data on the device. */
		printf("%16ld  (%ld kb) total\n", pos,
						(pos + RATIO(block_size) - 1) / RATIO(block_size));
	}
}

void install_master(char *device, char *masterboot, char **guide)
/* Booting a hard disk is a two stage process:  The master bootstrap in sector
 * 0 loads the bootstrap from sector 0 of the active partition which in turn
 * starts the operating system.  This code installs such a master bootstrap
 * on a hard disk.  If guide[0] is non-null then the master bootstrap is
 * guided into booting a certain device.
 */
{
	FILE *masf;
	unsigned long size;
	struct stat st;
	static char buf[_MAX_BLOCK_SIZE];

	/* Open device. */
	if ((rawfd= open(rawdev= device, O_RDWR)) < 0) fatal(device);

	/* Open the master boot code. */
	if ((masf= fopen(masterboot, "r")) == nil) fatal(masterboot);

	/* See if the user is cloning a device. */
	if (fstat(fileno(masf), &st) >=0 && S_ISBLK(st.st_mode))
		size= PARTPOS;
	else {
		/* Read and check header otherwise. */
		struct image_header ihdr;

		read_header(1, masterboot, masf, &ihdr);
		size= ihdr.process.a_text + ihdr.process.a_data;
	}
	if (size > PARTPOS) {
		fprintf(stderr, "installboot: %s is too big\n", masterboot);
		exit(1);
	}

	/* Read the master boot block, patch it, write. */
	readblock(BOOTBLOCK, buf, BOOT_BLOCK_SIZE);

	memset(buf, 0, PARTPOS);
	(void) bread(masf, masterboot, buf, size);

	if (guide[0] != nil) {
		/* Fixate partition to boot. */
		char *keys= guide[0];
		char *logical= guide[1];
		size_t i;
		int logfd;
		u32_t offset;
		struct partition geometry;

		/* A string of digits to be seen as keystrokes. */
		i= 0;
		do {
			if (!between('0', keys[i], '9')) {
				fprintf(stderr,
					"installboot: bad guide keys '%s'\n",
					keys);
				exit(1);
			}
		} while (keys[++i] != 0);

		if (size + i + 1 > PARTPOS) {
			fprintf(stderr,
			"installboot: not enough space after '%s' for '%s'\n",
				masterboot, keys);
			exit(1);
		}
		memcpy(buf + size, keys, i);
		size += i;
		buf[size]= '\r';

		if (logical != nil) {
			if ((logfd= open(logical, O_RDONLY)) < 0
				|| ioctl(logfd, DIOCGETP, &geometry) < 0
			) {
				fatal(logical);
			}
			offset= div64u(geometry.base, SECTOR_SIZE);
			if (size + 5 > PARTPOS) {
				fprintf(stderr,
					"installboot: not enough space "
					"after '%s' for '%s' and an offset "
					"to '%s'\n",
					masterboot, keys, logical);
				exit(1);
			}
			buf[size]= '#';
			memcpy(buf+size+1, &offset, 4);
		}
	}

	/* Install signature. */
	buf[SIGPOS+0]= (SIGNATURE >> 0) & 0xFF;
	buf[SIGPOS+1]= (SIGNATURE >> 8) & 0xFF;

	writeblock(BOOTBLOCK, buf, BOOT_BLOCK_SIZE);
}

void usage(void)
{
	fprintf(stderr,
	  "Usage: installboot -i(mage) image kernel mm fs ... init\n"
	  "       installboot -(e)x(tract) image\n"
	  "       installboot -d(evice) device bootblock boot [image ...]\n"
	  "       installboot -b(oot) device bootblock boot image ...\n"
	  "       installboot -m(aster) device masterboot [keys [logical]]\n");
	exit(1);
}

int isoption(char *option, char *test)
/* Check if the option argument is equals "test".  Also accept -i as short
 * for -image, and the special case -x for -extract.
 */
{
	if (strcmp(option, test) == 0) return 1;
	if (option[0] != '-' && strlen(option) != 2) return 0;
	if (option[1] == test[1]) return 1;
	if (option[1] == 'x' && test[1] == 'e') return 1;
	return 0;
}

int main(int argc, char **argv)
{
	if (argc < 2) usage();

	if (argc >= 4 && isoption(argv[1], "-image")) {
		make_image(argv[2], argv + 3);
	} else
	if (argc == 3 && isoption(argv[1], "-extract")) {
		extract_image(argv[2]);
	} else
	if (argc >= 5 && isoption(argv[1], "-device")) {
		make_bootable(FS, argv[2], argv[3], argv[4], argv + 5);
	} else
	if (argc >= 6 && isoption(argv[1], "-boot")) {
		make_bootable(BOOT, argv[2], argv[3], argv[4], argv + 5);
	} else
	if ((4 <= argc && argc <= 6) && isoption(argv[1], "-master")) {
		install_master(argv[2], argv[3], argv + 4);
	} else {
		usage();
	}
	exit(0);
}

/*
 * $PchId: installboot.c,v 1.10 2000/08/13 22:07:50 philip Exp $
 */