| /* |
| * This file is subject to the terms and conditions of the GNU General Public |
| * License. See the file "COPYING" in the main directory of this archive |
| * for more details. |
| * |
| * Copyright (C) Hewlett-Packard (Paul Bame) paul_bame@hp.com |
| */ |
| #define LONG_OPTIONS 1 |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <errno.h> |
| #include <unistd.h> |
| #include <assert.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include <sys/mman.h> |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #if LONG_OPTIONS |
| # define _GNU_SOURCE |
| # include <getopt.h> |
| #endif |
| #include "load.h" |
| #include "palo.h" |
| |
| |
| #define B32(x) __be32_to_cpu((x)) |
| |
| static const char Id[] = "$Id: palo.c,v 1.12.4.1 2001/06/13 03:13:17 bame Exp $"; |
| |
| static int Install = 0; |
| int verbose = 0; |
| |
| /* compute the sum of words in an 4-byte aligned region */ |
| int |
| checksum(void *p, size_t len) |
| { |
| int xsum = 0; |
| int *x = (int *)p; |
| int i; |
| |
| if (verbose) printf("checksum(%p, %u) = ", p, len); |
| len /= 4; |
| |
| for (i = 0; i < len; i++) |
| { |
| xsum += B32(x[i]); |
| } |
| |
| if (verbose) printf("0x%08x\n", xsum); |
| |
| return (xsum); |
| } |
| |
| static void |
| fb_init(struct firstblock *f) |
| { |
| f->lifmagic0 = 0x80; |
| f->lifmagic1 = 0x00; |
| f->rd_sz = f->kern32_sz = f->kern64_sz = 0; |
| f->rd_offset = f->kern32_offset = f->kern64_offset = 0; |
| strcpy(f->palomagic, PALOMAGIC); |
| f->version = PALOHDRVERSION; |
| f->flags = 0; |
| if (Install) |
| f->flags |= PFLAG_INSTALL; |
| } |
| |
| int |
| check_bootloader(int media, int line) |
| { |
| struct firstblock f; |
| int ipl_words; |
| int xsum; |
| unsigned int *ipl; |
| |
| if (verbose) printf("check_bootloader %d\n", line); |
| |
| STRUCTREAD(media, f, 0); |
| |
| if (f.lifmagic0 != 0x80 || f.lifmagic1 != 0x00) |
| { |
| fprintf(stderr, "0x%x 0x%x\n", f.lifmagic0, f.lifmagic1); |
| error(6, "LIF header"); |
| } |
| |
| if (B32(f.ipl_addr) < 2048 || |
| (B32(f.ipl_addr) % 2048) != 0) |
| error(6, "ipl_addr"); |
| |
| if (B32(f.ipl_size) <= 0 || |
| B32(f.ipl_size) >= 256 * 1024 || |
| (B32(f.ipl_size) % 2048) != 0) |
| error(6, "ipl_size"); |
| |
| if (B32(f.ipl_entry) >= B32(f.ipl_size) || |
| B32(f.ipl_entry) < 0 || |
| (B32(f.ipl_entry) % 4) != 0) |
| error(6, "ipl_entry"); |
| |
| ipl_words = B32(f.ipl_size) / sizeof ipl[0]; |
| |
| /* seekread the IPL */ |
| ipl = calloc(ipl_words, sizeof ipl[0]); |
| |
| /* would be a good idea to check this call? */ |
| if (seekread(media, (char *)ipl, B32(f.ipl_size), B32(f.ipl_addr)) == -1) |
| error(6, "read failed"); |
| |
| /* calculate xsum */ |
| xsum = checksum(ipl, B32(f.ipl_size)); |
| |
| if (xsum != 0) |
| { |
| fprintf(stderr, "calculated xsum 0x%x got 0x%x\n", |
| -xsum, ipl[ipl_words - 1]); |
| xsum -= B32(ipl[ipl_words - 1]); |
| fprintf(stderr, "calculated xsum 0x%x got 0x%x\n", |
| -xsum, ipl[ipl_words - 1]); |
| exit(2); |
| } |
| |
| printf("ipl: addr %d size %d entry 0x%x\n", |
| B32(f.ipl_addr), |
| B32(f.ipl_size), |
| B32(f.ipl_entry)); |
| |
| if (strncmp(f.palomagic, PALOMAGIC, 4) != 0) |
| { |
| error(6, "bad magic"); |
| } |
| |
| if (f.version != PALOHDRVERSION) |
| { |
| fprintf(stderr, "Warning!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n" |
| "Boot loader header version is %d, I only know how\n" |
| "to handle version %d. It MIGHT work anyway.\n", |
| f.version, PALOHDRVERSION); |
| } |
| |
| #if 1 |
| printf(" ko 0x%x ksz %d k64o 0x%x k64sz %d rdo %d rdsz %d\n<%s>\n", |
| B32(f.kern32_offset), B32(f.kern32_sz), |
| B32(f.kern64_offset), B32(f.kern64_sz), |
| B32(f.rd_offset), B32(f.rd_sz), |
| f.cmdline); |
| #endif |
| |
| return 1; |
| } |
| |
| |
| /* maximum allowed HP boot loader (IPL) size */ |
| #define MAXBLSIZE (256 * 1024) |
| |
| unsigned |
| write_bootloader(int media, int bootloader, |
| unsigned where, |
| unsigned f0end, |
| struct firstblock *f) |
| { |
| size_t rblsize; /* sector-rounded boot loader size */ |
| struct loadable loadable; |
| int xsum1; |
| void *blimage; |
| int r; |
| int wide; |
| |
| /* We want prepare_ to fail, otherwise we've been given the output */ |
| /* of the linker instead of mkbootable */ |
| r = prepare_loadable(bootloader, &loadable, &wide); |
| if (r) |
| error(12); |
| |
| /* make sure max size boot loader would fit */ |
| if (where + MAXBLSIZE > f0end) { |
| printf("where %d, where+MAX=%d f0end=%d\n", |
| where, where + MAXBLSIZE, f0end); |
| error(9); |
| } |
| /* load the boot loader into RAM */ |
| rblsize = fsize(bootloader); |
| assert((rblsize % FW_BLOCKSIZE) == 0); |
| blimage = (void *)calloc(1, rblsize); |
| assert(blimage != NULL); |
| if ((r = seekread(bootloader, blimage, rblsize, 0)) != rblsize) |
| error(13); |
| |
| /* Is it really a boot loader? */ |
| #define BLWORD1 0xe8000002 |
| if (BLWORD1 != __be32_to_cpu(*(unsigned *)blimage)) |
| { |
| fprintf(stderr, "ERROR: first word of boot loader was 0x%08x," |
| " expected 0x%08x\n", __be32_to_cpu(*(unsigned *)blimage), |
| BLWORD1); |
| exit(2); |
| } |
| |
| /* write it out */ |
| seekwrite(media, blimage, rblsize, where); |
| close(bootloader); |
| |
| f->ipl_addr = __cpu_to_be32(where); |
| f->ipl_size = __cpu_to_be32(rblsize); |
| /* entry point relative to where IPL is loaded in RAM by firmware */ |
| f->ipl_entry = __cpu_to_be32(loadable.entry - loadable.first); |
| |
| STRUCTWRITE(media, *f, 0); |
| |
| check_bootloader(media, __LINE__); |
| |
| free(blimage); |
| return where + rblsize; |
| } |
| |
| unsigned |
| write_kernel32(int media, int kernel, unsigned where, unsigned end, |
| struct firstblock *f) |
| { |
| /* always allow max size boot loader */ |
| f->kern32_offset = __cpu_to_be32(where); |
| f->kern32_sz = __cpu_to_be32(fsize(kernel)); |
| |
| if (B32(f->kern32_sz) + where >= end) |
| error(14, "32-bit-kernel"); |
| lseek(media, where, SEEK_SET); |
| return where + cat(media, kernel); |
| } |
| |
| unsigned |
| write_kernel64(int media, int kernel, unsigned where, unsigned end, |
| struct firstblock *f) |
| { |
| /* always allow max size boot loader */ |
| f->kern64_offset = __cpu_to_be32(where); |
| f->kern64_sz = __cpu_to_be32(fsize(kernel)); |
| |
| if (B32(f->kern64_sz) + where >= end) |
| error(14, "64-bit-kernel"); |
| lseek(media, where, SEEK_SET); |
| return where + cat(media, kernel); |
| } |
| |
| unsigned |
| write_ramdisk(int media, int rd, unsigned where, unsigned end, |
| struct firstblock *f) |
| { |
| /* always allow max size boot loader */ |
| f->rd_offset = __cpu_to_be32(where); |
| f->rd_sz = __cpu_to_be32(fsize(rd)); |
| |
| if (B32(f->rd_sz) + where >= end) |
| error(14, "ramdisk"); |
| |
| lseek(media, where, SEEK_SET); |
| where += cat(media, rd); |
| |
| return where; |
| } |
| |
| /* assumes the previous contents of the file are to be overwritten, */ |
| /* that kernel and bootloader are valid file pointers, and that */ |
| /* commandline will fit given size in fixed_pm. */ |
| void |
| do_sequential(int media, int kernel32, int kernel64, |
| const char *commandline, int bootloader, int ramdisk) |
| { |
| struct firstblock f; |
| /* always load IPL at second 2k block on sequential media */ |
| int where = 1 * FW_BLOCKSIZE; |
| unsigned end = 20 * 1024 * 1024; |
| |
| /* must have a boot loader for initialization */ |
| assert(bootloader != -1); |
| assert(kernel32 != -1 || kernel64 != 1); |
| |
| memset(&f, 0, sizeof f); |
| fb_init(&f); |
| |
| /* Update the boot loader, ignore size in this case */ |
| where = write_bootloader(media, bootloader, where, end, &f); |
| |
| if (kernel32 != -1) |
| where = write_kernel32(media, kernel32, where, end, &f); |
| |
| /* write some padding to the 2k boundary */ |
| where += write(media, &f, FW_BLOCKSIZE - (where % FW_BLOCKSIZE)); |
| |
| if (kernel64 != -1) |
| where = write_kernel64(media, kernel64, where, end, &f); |
| |
| /* write some padding to the 2k boundary */ |
| where += write(media, &f, FW_BLOCKSIZE - (where % FW_BLOCKSIZE)); |
| |
| if (ramdisk != -1) |
| where = write_ramdisk(media, ramdisk, where, end, &f); |
| |
| /* write some padding to the 2k boundary */ |
| where += write(media, &f, FW_BLOCKSIZE - (where % FW_BLOCKSIZE)); |
| |
| if (commandline != 0) |
| strcpy(f.cmdline, commandline); |
| |
| STRUCTWRITE(media, f, 0); |
| |
| check_bootloader(media, __LINE__); |
| } |
| |
| /* look on each 2k boundary for the file 'target' on 'media'. Assumes |
| * that 'target' is at least 2k in length. |
| */ |
| static int |
| lookfor(int media, int target) |
| { |
| char *targetptr; |
| char *mbuf; |
| int offset; |
| int r = -1; |
| int targetsize = fsize(target); |
| float mediasize = fsize(media); |
| |
| targetptr = mmap(0, targetsize, PROT_READ, MAP_SHARED, target, 0); |
| if ((int) targetptr == -1) |
| { |
| perror("mmap(targetptr)"); |
| return -1; |
| } |
| |
| mbuf = malloc(targetsize); |
| assert(mbuf != NULL); |
| |
| for (offset = 0; 1; offset += 2048) |
| { |
| int n; |
| const int PREVIEW = 512; |
| |
| n = seekread(media, mbuf, PREVIEW, offset); |
| if (n < PREVIEW) |
| break; |
| if (memcmp(mbuf, targetptr, PREVIEW) == 0) |
| { |
| n = seekread(media, mbuf, targetsize, offset); |
| if (n < targetsize) |
| break; |
| if (memcmp(mbuf, targetptr, targetsize) == 0) |
| { |
| r = offset; |
| break; |
| } |
| } |
| } |
| |
| munmap(targetptr, targetsize); |
| free(mbuf); |
| |
| return r; |
| } |
| |
| /* Given a writeable ISO9660 CD image containing within its file system |
| * both the boot loader and kernel specified also on the palo command line, |
| * write a "sequential" or "F0" type boot header. |
| */ |
| void |
| do_cdrom(int media, int kernel32, int kernel64, |
| const char *commandline, int bootloader, int ramdisk) |
| { |
| struct firstblock f; |
| /* always load IPL at second 2k block on sequential media */ |
| int where = 1 * FW_BLOCKSIZE; |
| unsigned end = 800 * 1024 * 1024; |
| /* int is safe since CD-ROM is < 2G */ |
| int bootloader_offset; |
| int kernel32_offset; |
| int kernel64_offset; |
| int ramdisk_offset; |
| |
| /* must have a boot loader and kernel */ |
| assert(bootloader != -1); |
| assert(kernel32 != -1 || kernel64 != 1); |
| |
| /* read the first block/sector, which is FW_BLOCKSIZE, which also */ |
| /* conveniently is the CD block size too */ |
| /* STRUCTREAD(media, f, 0); Probably don't need to read it... */ |
| memset(&f, 0, sizeof f); |
| fb_init(&f); |
| |
| /* search the ISO image for the boot loader and kernel files */ |
| if ((bootloader_offset = lookfor(media, bootloader)) == -1) |
| { |
| error(15, "boot loader"); |
| } |
| |
| if (kernel32 != -1 && (kernel32_offset = lookfor(media, kernel32)) == -1) |
| error(15, "32-bit-kernel image"); |
| |
| if (kernel64 != -1 && (kernel64_offset = lookfor(media, kernel64)) == -1) |
| error(15, "64-bit-kernel image"); |
| |
| if (ramdisk != -1) |
| { |
| if ((ramdisk_offset = lookfor(media, ramdisk)) == -1) |
| error(15, "ramdisk image"); |
| } |
| |
| /* Overwrite the boot loader because write_bootloader() is easy to use */ |
| write_bootloader(media, bootloader, bootloader_offset, end, &f); |
| |
| /* Overwrite the kernel because write_kernel() is easy to use */ |
| if (kernel32 != -1) |
| write_kernel32(media, kernel32, kernel32_offset, end, &f); |
| |
| if (kernel64 != -1) |
| write_kernel64(media, kernel64, kernel64_offset, end, &f); |
| |
| if (ramdisk != -1) |
| { |
| write_ramdisk(media, ramdisk, ramdisk_offset, end, &f); |
| } |
| |
| if (commandline != 0) |
| strcpy(f.cmdline, commandline); |
| |
| STRUCTWRITE(media, f, 0); |
| |
| check_bootloader(media, __LINE__); |
| } |
| |
| #define KSIZE (2 * 1024 * 1024) |
| |
| /* Blocksize for the ext2/3 fs in the palo partition */ |
| #define EXT2_BLOCKSIZE 1024 |
| |
| /* size in ext2 blocks of hole for bootloader */ |
| #define EXT2_HOLE ((MAXBLSIZE + 1) / EXT2_BLOCKSIZE) |
| |
| /* offset in bytes before start of hole, ext2 doesn't allow holes at |
| * to cover the first four blocks of the filesystem */ |
| #define EXT2_OFFSET (4*EXT2_BLOCKSIZE) |
| |
| int |
| do_formatted(int init, int media, const char *medianame, int partition, |
| int f0start, int f0length, int bootloaderfd, int do_format, |
| const char *commandline) |
| { |
| char partitionname[256]; |
| struct firstblock f; |
| int partitionfd; |
| |
| /* FIXME: assuming we can simply add the partition to the end |
| * of the whole disc device isn't always true */ |
| snprintf(partitionname, sizeof(partitionname), "%s%d", medianame, |
| partition); |
| |
| if ((partitionfd = open(partitionname, O_RDWR)) < 0) { |
| perror(partitionname); |
| exit(1); |
| } |
| close(partitionfd); |
| |
| if (init) { |
| /* make the bootloader align at 256k */ |
| unsigned int holestart = (f0start + 0x3ffff + EXT2_OFFSET) & ~0x3ffff; |
| unsigned int partition_offset = holestart - f0start; |
| char badblockfilename[256]; |
| int fd, i; |
| char cmd[512]; |
| |
| printf("Initializing %s as ext%d\n", partitionname, do_format); |
| |
| if (verbose) |
| printf("f0 partition starts %d, hole %d-%d, end %d\n", |
| f0start, holestart, holestart + EXT2_HOLE*EXT2_BLOCKSIZE, |
| f0start + f0length); |
| |
| if(partition_offset + EXT2_HOLE > f0length) |
| error(14, "bootloader"); |
| |
| sprintf(badblockfilename, "/tmp/paloblk-%d", getpid()); |
| if ((fd = open(badblockfilename, O_RDWR | O_CREAT | O_TRUNC)) < 0) { |
| perror(badblockfilename); |
| exit(1); |
| } |
| |
| for (i = (holestart - f0start)/EXT2_BLOCKSIZE; |
| i < (holestart - f0start)/EXT2_BLOCKSIZE + EXT2_HOLE; i++) { |
| char buf[128]; |
| sprintf(buf, "%d\n", i); |
| write(fd, buf, strlen(buf)); |
| } |
| |
| sprintf(cmd, "mke2fs %s -b %d -l %s %s", do_format == 3 ? "-j" : "", |
| EXT2_BLOCKSIZE, badblockfilename, partitionname); |
| |
| if (verbose) |
| printf("Executing: %s\n", cmd); |
| else |
| strcat(cmd, " > /dev/null 2>&1"); |
| |
| i = system(cmd); |
| unlink(badblockfilename); |
| |
| if(WEXITSTATUS(i) != 0) |
| error(19, WEXITSTATUS(i)); |
| |
| |
| |
| STRUCTREAD(media, f, 0); |
| fb_init(&f); |
| f.flags |= PFLAG_EXT2; |
| |
| if(commandline) |
| strncpy(f.cmdline, commandline, sizeof(f.cmdline)); |
| |
| write_bootloader(media, bootloaderfd, holestart, |
| holestart + EXT2_HOLE*EXT2_BLOCKSIZE, &f); |
| |
| STRUCTWRITE(media, f, 0); |
| |
| } else { |
| STRUCTREAD(media, f, 0); |
| |
| if(verbose) |
| printf("Updating formatted ver=%d, start=%d\n", |
| f.version, f.ipl_addr); |
| |
| if ((f.version < 4) || (!f.flags & PFLAG_EXT2)) { |
| printf("Can not update %s. Please initialize first.\n", |
| partitionname); |
| return -1; |
| } |
| |
| if(commandline) |
| strncpy(f.cmdline, commandline, sizeof(f.cmdline)); |
| |
| write_bootloader(media, bootloaderfd, f.ipl_addr, |
| f.ipl_addr + EXT2_HOLE*EXT2_BLOCKSIZE, &f); |
| |
| STRUCTWRITE(media, f, 0); |
| } |
| return 0; |
| } |
| |
| void |
| do_randomaccess(int init, int media, int kernel32, int kernel64, |
| const char *commandline, int bootloader, int ramdisk, |
| unsigned f0start, unsigned f0length) |
| { |
| struct firstblock f; |
| int bstart = 0; |
| |
| if (verbose) printf("do_ra(%d, %d, %d, %d, '%s', %d, %d, %u, %u)\n", |
| init, media, kernel32, kernel64, commandline, bootloader, ramdisk, f0start, |
| f0length); |
| |
| assert((f0start % 512) == 0); |
| |
| /* figure out where the boot loader should be */ |
| /* f0start is a sector (512-byte) multiple. IPL must be aligned 2k */ |
| bstart = (f0start + 2047) & ~2047; |
| |
| if (init) |
| { |
| /* initialize a partitioned medium */ |
| unsigned where = bstart; |
| unsigned end = f0start + f0length; |
| |
| /* must have a boot loader for initialization */ |
| assert(bootloader != -1); |
| |
| STRUCTREAD(media, f, 0); |
| fb_init(&f); |
| |
| /* Update the boot loader, ignore size in this case */ |
| write_bootloader(media, bootloader, where, end, &f); |
| |
| where += MAXBLSIZE; |
| |
| if (kernel32 != -1) |
| { |
| unsigned p, ksize; |
| p = write_kernel32(media, kernel32, where, end, &f); |
| |
| ksize = p - where; |
| |
| /* allow for bigger kernels */ |
| if (ksize < KSIZE) |
| ksize = KSIZE; |
| |
| where = p; |
| } |
| |
| if (kernel64 != -1) |
| { |
| unsigned p, ksize; |
| p = write_kernel64(media, kernel64, where, end, &f); |
| |
| ksize = p - where; |
| |
| /* allow for bigger kernels */ |
| if (ksize < KSIZE) |
| ksize = KSIZE; |
| |
| where = p; |
| } |
| |
| if (ramdisk != -1) |
| where = write_ramdisk(media, ramdisk, where, end, &f); |
| |
| if (commandline != 0) |
| strcpy(f.cmdline, commandline); |
| |
| STRUCTWRITE(media, f, 0); |
| } |
| else /* update */ |
| { |
| unsigned end = f0start + f0length; |
| |
| fprintf(stderr, "palo -U doesn't work yet\n"); exit(2); |
| #if 0 |
| |
| /* make sure we have a good bootloader on there now */ |
| check_bootloader(media, __LINE__); |
| |
| /* update a partitioned medium */ |
| STRUCTREAD(media, f, 0); |
| |
| if (bootloader != -1) |
| { |
| write_bootloader(media, bootloader, bstart, B32(f.kern_offset), &f); |
| } |
| |
| if (kernel != -1) |
| { |
| write_kernel(media, kernel, B32(f.kern_offset), |
| B32(f.rd_offset), &f); |
| } |
| |
| if (kernel != -1) |
| { |
| write_kernel(media, kernel, B32(f.kern_offset), |
| B32(f.rd_offset), &f); |
| } |
| |
| if (ramdisk != -1) |
| { |
| write_ramdisk(media, ramdisk, B32(f.rd_offset), end, &f); |
| } |
| |
| if (commandline != 0) |
| strcpy(f.cmdline, commandline); |
| |
| STRUCTWRITE(media, f, 0); |
| #endif |
| } |
| |
| check_bootloader(media, __LINE__); |
| } |
| |
| #define MAXARGS 200 |
| |
| #if LONG_OPTIONS |
| static struct option Longopts[] = |
| { |
| {"configfile", 1, 0, 'f'}, |
| {"commandline", 1, 0, 'c'}, |
| {"recoverykernel", 1, 0, 'k'}, |
| {"bootloader", 1, 0, 'b'}, |
| {"ramdisk", 1, 0, 'r'}, |
| {"init-partitioned", 1, 0, 'I'}, |
| {"format-as", 1, 0, 'e'}, |
| {"update-partitioned", 1, 0, 'U'}, |
| {"init-tape", 1, 0, 's'}, |
| {"init-cdrom", 1, 0, 'C'}, |
| {"verbose", 0, 0, 'v'}, |
| {"help", 0, 0, '?'}, |
| {0, 0, 0, 0} |
| }; |
| # define GETOPT(argc, argv, optstring) \ |
| getopt_long(argc, argv, optstring, Longopts, 0) |
| #else |
| # define GETOPT(argc, argv, optstring) getopt(argc, argv, optstring) |
| #endif |
| |
| int |
| main(int argc, char *argv[]) |
| { |
| int c; |
| enum {SEQUENTIAL, PARTITIONED, CDROM} mediatype = PARTITIONED; |
| int bootloader = -1; |
| int kernel32 = -1; |
| int kernel64 = -1; |
| int fd; |
| struct loadable loadable; |
| int wide; |
| char *commandline = 0; |
| int media = -1; |
| int ramdisk = -1; |
| int cdrom = 0; |
| char *medianame = NULL; |
| char *bootloaderfile = "/usr/share/palo/iplboot"; |
| int init = 0; |
| extern char *bld_info; |
| const char gargs[] = "f:C:s:b:k:c:r:I:e:U:v?"; |
| char *config_file = "/etc/palo.conf"; |
| char *newargv[MAXARGS]; |
| int newargc, format_as = 0; |
| FILE *fconfig; |
| |
| assert(sizeof (struct firstblock) == 2048); |
| { |
| struct firstblock f; |
| assert((unsigned)&f.kern32_offset - (unsigned)&f == 8); |
| assert((unsigned)&f.ipl_addr - (unsigned)&f == 0xf0); |
| } |
| |
| fputs("palo version " PALOVERSION " ", stdout); |
| puts(bld_info); |
| |
| /* do we have a -f? */ |
| while ((c = GETOPT(argc, argv, gargs)) != EOF) |
| { |
| switch(c) |
| { |
| case 'f': |
| config_file = optarg; |
| break; |
| case '?': |
| error(0, argv[0]); |
| } |
| } |
| |
| newargc = 0; |
| newargv[newargc++] = argv[0]; |
| /* grab args from the config file */ |
| if ((fconfig = fopen(config_file, "r")) == NULL) |
| { |
| fprintf(stderr, "Warning: "); |
| perror(config_file); |
| } |
| else |
| { |
| char buf[256]; |
| |
| while(newargc < MAXARGS && fgets(buf, sizeof buf, fconfig) != NULL) |
| { |
| char *ptr = buf; |
| char *end; |
| |
| /* skip over leading whitespace */ |
| while (isspace(*ptr)) |
| ptr++; |
| |
| /* skip comment */ |
| if (*ptr == '#') |
| continue; |
| |
| /* strip trailing whitespace */ |
| end = ptr + strlen(ptr) - 1; |
| while (isspace(*end)) |
| end--; |
| *++end = '\0'; |
| |
| /* skip blank lines */ |
| if (*ptr == '\0') |
| continue; |
| |
| newargv[newargc++] = strdup(buf); |
| } |
| fclose(fconfig); |
| } |
| |
| /* add the original command-line args */ |
| for (c = 1; c < argc && newargc < MAXARGS; c++) |
| { |
| newargv[newargc++] = argv[c]; |
| } |
| |
| /* NULL pointer for good measure */ |
| if (newargc < MAXARGS) |
| newargv[newargc] = 0; |
| |
| /* convince getopt to re-start */ |
| optind = 1; |
| |
| while ((c = GETOPT(newargc, newargv, gargs)) != EOF) |
| { |
| switch(c) |
| { |
| case 'f': |
| break; |
| case 'C': |
| mediatype = CDROM; |
| medianame = optarg; |
| break; |
| case 'I': |
| init = 1; |
| mediatype = PARTITIONED; |
| medianame = optarg; |
| break; |
| case 'U': |
| init = 0; |
| mediatype = PARTITIONED; |
| medianame = optarg; |
| break; |
| case 's': |
| mediatype = SEQUENTIAL; |
| medianame = optarg; |
| break; |
| case 'b': |
| bootloaderfile = optarg; |
| break; |
| case 'k': |
| if ((fd = open(optarg, O_RDONLY)) == -1) |
| { |
| perror(optarg); |
| return 2; |
| } |
| if (!prepare_loadable(fd, &loadable, &wide)) |
| error(16, optarg); |
| if ((wide && kernel64 != -1) || (!wide && kernel32 != -1)) |
| error(17, optarg); |
| lseek(fd, 0, SEEK_SET); /* rewind */ |
| if (wide) |
| kernel64 = fd; |
| else |
| kernel32 = fd; |
| break; |
| case 'r': |
| if ((ramdisk = open(optarg, O_RDONLY)) == -1) |
| { |
| perror(optarg); |
| return 2; |
| } |
| break; |
| case 'c': |
| commandline = optarg; |
| if (strlen(commandline) > 127) |
| error(3,127,strlen(commandline)); |
| break; |
| case 'e': |
| if(strcmp(optarg, "2") == 0) |
| format_as = 2; |
| else if(strcmp(optarg, "3") == 0) |
| format_as = 3; |
| else |
| error(0, argv[0]); |
| break; |
| case 'v': |
| verbose = 1; |
| break; |
| default: |
| error(0, argv[0]); |
| break; |
| } |
| } |
| |
| if ((bootloader = open(bootloaderfile, O_RDONLY)) == -1) |
| { |
| perror(bootloaderfile); |
| return 2; |
| } |
| |
| if (optind < argc) |
| { |
| error(0, argv[0]); |
| } |
| |
| if (medianame == NULL) |
| { |
| fprintf(stderr, "%s: Need one of -CIs or -U\n", argv[0]); |
| error(0, argv[0]); |
| } |
| |
| switch (mediatype) |
| { |
| case SEQUENTIAL: |
| if ((media = open(medianame, O_RDWR|O_CREAT, 0666)) == -1) |
| { |
| perror(medianame); |
| return 2; |
| } |
| do_sequential(media, kernel32, kernel64, commandline, bootloader, ramdisk); |
| break; |
| case PARTITIONED: |
| { |
| struct diskpartition ptab[MAXPARTS]; |
| int partitioned; |
| int f0; |
| struct firstblock f; |
| |
| memset(ptab, 0, sizeof ptab); |
| |
| /* non-sequential boot creation requires a file/device */ |
| if ((media = open(medianame, O_RDWR)) == -1) |
| { |
| perror(medianame); |
| if (errno == ENOENT) /* file probably doesn't exist */ |
| { |
| error(1); |
| } |
| return 2; |
| } |
| |
| /* it better have a partition table too... */ |
| partitioned = load_partitions(media, ptab, MAXPARTS); |
| if (!partitioned) |
| { |
| error(10); |
| } |
| |
| /* find the F0 partition */ |
| for (f0 = 0; f0 < MAXPARTS; f0++) |
| { |
| if (ptab[f0].id == PALO_PARTITION) |
| break; |
| } |
| if (f0 == MAXPARTS) |
| error(11); |
| if(verbose) { |
| print_ptab_pretty(ptab, MAXPARTS); |
| |
| printf("F0 partition start sector %d length %d\n", |
| ptab[f0].start, ptab[f0].length); |
| } |
| |
| if (format_as) { |
| /* if we're going to be a formatted partition, we can't |
| * load anything into it, so check we haven't been asked |
| * to */ |
| if(kernel32 != -1 || kernel64 != -1 || ramdisk != -1) |
| error(18); |
| |
| if (do_formatted(init, media, medianame, f0 + 1, |
| ptab[f0].start * 512, ptab[f0].length * 512, |
| bootloader, format_as, commandline)) |
| error(20); |
| } else |
| do_randomaccess(init, media, kernel32, kernel64, commandline, |
| bootloader, ramdisk, ptab[f0].start * 512, |
| ptab[f0].length * 512); |
| } |
| break; |
| case CDROM: |
| if ((media = open(medianame, O_RDWR)) == -1) |
| { |
| perror(medianame); |
| return 2; |
| } |
| do_cdrom(media, kernel32, kernel64, commandline, bootloader, ramdisk); |
| break; |
| } |
| |
| fsync(media); |
| close(media); |
| |
| return 0; |
| } |