[oweals/busybox.git] / sfdisk.c

/* vi: set sw=4 ts=4: */
/*
 * sfdisk version 3.0 - aeb - 950813
 *
 * Copyright (C) 1995  Andries E. Brouwer (aeb@cwi.nl)
 *
 * This program 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 1
 * or (at your option) any later version.
 *
 * A.V. Le Blanc (LeBlanc@mcc.ac.uk) wrote Linux fdisk 1992-1994,
 * patched by various people (faith@cs.unc.edu, martin@cs.unc.edu,
 * leisner@sdsp.mc.xerox.com, esr@snark.thyrsus.com, aeb@cwi.nl)
 * 1993-1995, with version numbers (as far as I have seen) 0.93 - 2.0e.
 * This program had (head,sector,cylinder) as basic unit, and was
 * (therefore) broken in several ways for the use on larger disks -
 * for example, my last patch (from 2.0d to 2.0e) was required
 * to allow a partition to cross cylinder 8064, and to write an
 * extended partition past the 4GB mark.
 *
 * The current program is a rewrite from scratch, and I started a
 * version numbering at 3.0.
 *      Andries Brouwer, aeb@cwi.nl, 950813
 *
 * Well, a good user interface is still lacking. On the other hand,
 * many configurations cannot be handled by any other fdisk.
 * I changed the name to sfdisk to prevent confusion. - aeb, 970501
 *
 * Changes:
 * 19990319 - Arnaldo Carvalho de Melo <acme@conectiva.com.br> - i18n
 *
 * busyboxed by Erik Andersen <andersee@debian.org> -- I stipped out
 * all the NLS, pulled in some includes, and made stuff smaller...
 */

#define PROGNAME "sfdisk"
#define VERSION "3.07"
#define DATE "990908"

#include "internal.h"
#include <stdio.h>
#include <stdlib.h>                             /* atoi, free */
#include <stdarg.h>                             /* varargs */
#include <unistd.h>                             /* read, write */
#include <fcntl.h>                              /* O_RDWR */
#include <errno.h>                              /* ERANGE */
#include <string.h>                             /* index() */
#include <ctype.h>
#include <getopt.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <linux/unistd.h>               /* _syscall */
#include <linux/hdreg.h>                /* HDIO_GETGEO */
#include <linux/fs.h>                   /* BLKGETSIZE */

#define BB_DECLARE_EXTERN
#define bb_need_memory_exhausted
#include "messages.c"

static const char sfdisk_usage[] =
        "sfdisk [options] device ...\n"
#ifndef BB_FEATURE_TRIVIAL_HELP
        "\ndevice: something like /dev/hda or /dev/sda\n"
        "useful options:\n"
        "    -s [or --show-size]: list size of a partition\n"
        "    -c [or --id]:        print or change partition Id\n"
        "    -l [or --list]:      list partitions of each device\n"
        "    -d [or --dump]:      idem, but in a format suitable for later input\n"
        "    -i [or --increment]: number cylinders etc. from 1 instead of from 0\n"
        "    -uS, -uB, -uC, -uM:  accept/report in units of sectors/blocks/cylinders/MB\n"
        "    -T [or --list-types]:list the known partition types\n"
        "    -D [or --DOS]:       for DOS-compatibility: waste a little space\n"
        "    -R [or --re-read]:   make kernel reread partition table\n"
        "    -N# :                change only the partition with number #\n"
        "    -n :                 do not actually write to disk\n"
        "    -O file :            save the sectors that will be overwritten to file\n"
        "    -I file :            restore these sectors again\n"
        "    -v [or --version]:   print version\n"
        "    -? [or --help]:      print this message\n"
        "dangerous options:\n"
        "    -g [or --show-geometry]: print the kernel's idea of the geometry\n"
        "    -x [or --show-extended]: also list extended partitions on output\n\n"
        "                             or expect descriptors for them on input\n"
        "    -L  [or --Linux]:      do not complain about things irrelevant for Linux\n"
        "    -q  [or --quiet]:      suppress warning messages\n"
        "    You can override the detected geometry using:\n"
        "    -C# [or --cylinders #]:set the number of cylinders to use\n"
        "    -H# [or --heads #]:    set the number of heads to use\n"
        "    -S# [or --sectors #]:  set the number of sectors to use\n"

        "You can disable all consistency checking with:\n"
        "    -f  [or --force]:      do what I say, even if it is stupid\n"
#endif
        ;



/* common stuff for fdisk, cfdisk, sfdisk */
struct systypes {
        unsigned char type;
        char *name;
};

static struct systypes i386_sys_types[] = {
        {0x00, "Empty"},
        {0x01, "FAT12"},
        {0x02, "XENIX root"},
        {0x03, "XENIX usr"},
        {0x04, "FAT16 <32M"},
        {0x05, "Extended"},                     /* DOS 3.3+ extended partition */
        {0x06, "FAT16"},                        /* DOS 16-bit >=32M */
        {0x07, "HPFS/NTFS"},            /* OS/2 IFS, eg, HPFS or NTFS or QNX */
        {0x08, "AIX"},                          /* AIX boot (AIX -- PS/2 port or SplitDrive) */
        {0x09, "AIX bootable"},         /* AIX data or Coherent */
        {0x0a, "OS/2 Boot Manager"},    /* OS/2 Boot Manager */
        {0x0b, "Win95 FAT32"},
        {0x0c, "Win95 FAT32 (LBA)"},    /* LBA really is `Extended Int 13h' */
        {0x0e, "Win95 FAT16 (LBA)"},
        {0x0f, "Win95 Ext'd (LBA)"},
        {0x10, "OPUS"},
        {0x11, "Hidden FAT12"},
        {0x12, "Compaq diagnostics"},
        {0x14, "Hidden FAT16 <32M"},
        {0x16, "Hidden FAT16"},
        {0x17, "Hidden HPFS/NTFS"},
        {0x18, "AST Windows swapfile"},
        {0x1b, "Hidden Win95 FAT32"},
        {0x1c, "Hidden Win95 FAT32 (LBA)"},
        {0x1e, "Hidden Win95 FAT16 (LBA)"},
        {0x24, "NEC DOS"},
        {0x3c, "PartitionMagic recovery"},
        {0x40, "Venix 80286"},
        {0x41, "PPC PReP Boot"},
        {0x42, "SFS"},
        {0x4d, "QNX4.x"},
        {0x4e, "QNX4.x 2nd part"},
        {0x4f, "QNX4.x 3rd part"},
        {0x50, "OnTrack DM"},
        {0x51, "OnTrack DM6 Aux1"},     /* (or Novell) */
        {0x52, "CP/M"},                         /* CP/M or Microport SysV/AT */
        {0x53, "OnTrack DM6 Aux3"},
        {0x54, "OnTrackDM6"},
        {0x55, "EZ-Drive"},
        {0x56, "Golden Bow"},
        {0x5c, "Priam Edisk"},
        {0x61, "SpeedStor"},
        {0x63, "GNU HURD or SysV"},     /* GNU HURD or Mach or Sys V/386 (such as ISC UNIX) */
        {0x64, "Novell Netware 286"},
        {0x65, "Novell Netware 386"},
        {0x70, "DiskSecure Multi-Boot"},
        {0x75, "PC/IX"},
        {0x80, "Old Minix"},            /* Minix 1.4a and earlier */
        {0x81, "Minix / old Linux"},    /* Minix 1.4b and later */
        {0x82, "Linux swap"},           /* also Solaris */
        {0x83, "Linux"},
        {0x84, "OS/2 hidden C: drive"},
        {0x85, "Linux extended"},
        {0x86, "NTFS volume set"},
        {0x87, "NTFS volume set"},
        {0x93, "Amoeba"},
        {0x94, "Amoeba BBT"},           /* (bad block table) */
        {0xa0, "IBM Thinkpad hibernation"},
        {0xa5, "BSD/386"},
        {0xa6, "OpenBSD"},
        {0xa7, "NeXTSTEP"},
        {0xb7, "BSDI fs"},
        {0xb8, "BSDI swap"},
        {0xc1, "DRDOS/sec (FAT-12)"},
        {0xc4, "DRDOS/sec (FAT-16 < 32M)"},
        {0xc6, "DRDOS/sec (FAT-16)"},
        {0xc7, "Syrinx"},
        {0xdb, "CP/M / CTOS / ..."},    /* CP/M or Concurrent CP/M or Concurrent DOS or CTOS */
        {0xe1, "DOS access"},           /* DOS access or SpeedStor 12-bit FAT extended partition */
        {0xe3, "DOS R/O"},                      /* DOS R/O or SpeedStor */
        {0xe4, "SpeedStor"},            /* SpeedStor 16-bit FAT extended partition < 1024 cyl. */
        {0xeb, "BeOS fs"},
        {0xf1, "SpeedStor"},
        {0xf4, "SpeedStor"},            /* SpeedStor large partition */
        {0xf2, "DOS secondary"},        /* DOS 3.3+ secondary */
        {0xfd, "Linux raid autodetect"},        /* New (2.2.x) raid partition with autodetect
                                                                                   using persistent superblock */
        {0xfe, "LANstep"},                      /* SpeedStor >1024 cyl. or LANstep */
        {0xff, "BBT"},                          /* Xenix Bad Block Table */
        {0, 0}
};

#define SIZE(a) (sizeof(a)/sizeof(a[0]))

/*
 * Table of contents:
 *  A. About seeking
 *  B. About sectors
 *  C. About heads, sectors and cylinders
 *  D. About system Ids
 *  E. About partitions
 *  F. The standard input
 *  G. The command line
 *  H. Listing the current situation
 *  I. Writing the new situation
 */
static int exit_status = 0;

static int force = 0;                   /* 1: do what I say, even if it is stupid ... */
static int quiet = 0;                   /* 1: suppress all warnings */
static int Linux = 0;                   /* 1: suppress warnings irrelevant for Linux */
static int DOS = 0;                             /* 1: shift extended partitions by #sectors, not 1 */
static int dump = 0;                    /* 1: list in a format suitable for later input */
static int verify = 0;                  /* 1: check that listed partition is reasonable */
static int no_write = 0;                /* 1: do not actually write to disk */
static int no_reread = 0;               /* 1: skip the BLKRRPART ioctl test at startup */
static int leave_last = 0;              /* 1: don't allocate the last cylinder */
static int opt_list = 0;
static char *save_sector_file = NULL;
static char *restore_sector_file = NULL;

static void warn(char *s, ...) __attribute__ ((format (printf, 1, 2)));
static void warn(char *s, ...)
{
        va_list p;

        va_start(p, s);
        fflush(stdout);
        if (!quiet)
                vfprintf(stderr, s, p);
        va_end(p);
}

/*
 *  A. About seeking
 */

/*
 * sseek: seek to specified sector - return 0 on failure
 *
 * For >4GB disks lseek needs a > 32bit arg, and we have to use llseek.
 * On the other hand, a 32 bit sector number is OK until 2TB.
 * The routines _llseek and sseek below are the only ones that
 * know about the loff_t type.
 */
#ifndef __alpha__
static
_syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
                  loff_t *, res, uint, wh);
#endif

static int sseek(char *dev, unsigned int fd, unsigned long s)
{
        loff_t in, out;

        in = ((loff_t) s << 9);
        out = 1;

#ifndef __alpha__
        if (_llseek(fd, in >> 32, in & 0xffffffff, &out, SEEK_SET) != 0) {
#else
        if ((out = lseek(fd, in, SEEK_SET)) != in) {
#endif
                perror("llseek");
                errorMsg("seek error on %s - cannot seek to %lu\n", dev, s);
                return 0;
        }

        if (in != out) {
                errorMsg("seek error: wanted 0x%08x%08x, got 0x%08x%08x\n",
                          (uint) (in >> 32), (uint) (in & 0xffffffff),
                          (uint) (out >> 32), (uint) (out & 0xffffffff));
                return 0;
        }
        return 1;
}

/*
 *  B. About sectors
 */

/*
 * We preserve all sectors read in a chain - some of these will
 * have to be modified and written back.
 */
struct sector {
        struct sector *next;
        unsigned long sectornumber;
        int to_be_written;
        char data[512];
} *sectorhead;

static void free_sectors(void)
{
        struct sector *s;

        while (sectorhead) {
                s = sectorhead;
                sectorhead = s->next;
                free(s);
        }
}

static struct sector *get_sector(char *dev, int fd, unsigned long sno)
{
        struct sector *s;

        for (s = sectorhead; s; s = s->next)
                if (s->sectornumber == sno)
                        return s;

        if (!sseek(dev, fd, sno))
                return 0;

        s = (struct sector *) xmalloc(sizeof(struct sector));

        if (read(fd, s->data, sizeof(s->data)) != sizeof(s->data)) {
                perror("read");
                errorMsg("read error on %s - cannot read sector %lu\n", dev, sno);
                free(s);
                return 0;
        }

        s->next = sectorhead;
        sectorhead = s;
        s->sectornumber = sno;
        s->to_be_written = 0;

        return s;
}

static int msdos_signature(struct sector *s)
{
        if (*(unsigned short *) (s->data + 0x1fe) != 0xaa55) {
                errorMsg("ERROR: sector %lu does not have an msdos signature\n",
                          s->sectornumber);
                return 0;
        }
        return 1;
}

static int write_sectors(char *dev, int fd)
{
        struct sector *s;

        for (s = sectorhead; s; s = s->next)
                if (s->to_be_written) {
                        if (!sseek(dev, fd, s->sectornumber))
                                return 0;
                        if (write(fd, s->data, sizeof(s->data)) != sizeof(s->data)) {
                                perror("write");
                                errorMsg("write error on %s - cannot write sector %lu\n",
                                          dev, s->sectornumber);
                                return 0;
                        }
                        s->to_be_written = 0;
                }
        return 1;
}

static void ulong_to_chars(unsigned long u, char *uu)
{
        int i;

        for (i = 0; i < 4; i++) {
                uu[i] = (u & 0xff);
                u >>= 8;
        }
}

static unsigned long chars_to_ulong(unsigned char *uu)
{
        int i;
        unsigned long u = 0;

        for (i = 3; i >= 0; i--)
                u = (u << 8) | uu[i];
        return u;
}

static int save_sectors(char *dev, int fdin)
{
        struct sector *s;
        char ss[516];
        int fdout;

        fdout = open(save_sector_file, O_WRONLY | O_CREAT, 0444);
        if (fdout < 0) {
                perror(save_sector_file);
                errorMsg("cannot open partition sector save file (%s)\n",
                          save_sector_file);
                return 0;
        }

        for (s = sectorhead; s; s = s->next)
                if (s->to_be_written) {
                        ulong_to_chars(s->sectornumber, ss);
                        if (!sseek(dev, fdin, s->sectornumber))
                                return 0;
                        if (read(fdin, ss + 4, 512) != 512) {
                                perror("read");
                                errorMsg("read error on %s - cannot read sector %lu\n",
                                          dev, s->sectornumber);
                                return 0;
                        }
                        if (write(fdout, ss, sizeof(ss)) != sizeof(ss)) {
                                perror("write");
                                errorMsg("write error on %s\n", save_sector_file);
                                return 0;
                        }
                }
        return 1;
}

static void reread_disk_partition(char *dev, int fd);

static int restore_sectors(char *dev)
{
        int fdin, fdout, ct;
        struct stat statbuf;
        char *ss0, *ss;
        unsigned long sno;

        if (stat(restore_sector_file, &statbuf) < 0) {
                perror(restore_sector_file);
                errorMsg("cannot stat partition restore file (%s)\n",
                          restore_sector_file);
                return 0;
        }
        if (statbuf.st_size % 516) {
                errorMsg("partition restore file has wrong size - not restoring\n");
                return 0;
        }
        if (!(ss = (char *) malloc(statbuf.st_size))) {
                errorMsg(memory_exhausted, "sfdisk");
                return 0;
        }
        fdin = open(restore_sector_file, O_RDONLY);
        if (fdin < 0) {
                perror(restore_sector_file);
                errorMsg("cannot open partition restore file (%s)\n",
                          restore_sector_file);
                return 0;
        }
        if (read(fdin, ss, statbuf.st_size) != statbuf.st_size) {
                perror("read");
                errorMsg("error reading %s\n", restore_sector_file);
                return 0;
        }

        fdout = open(dev, O_WRONLY);
        if (fdout < 0) {
                perror(dev);
                errorMsg("cannot open device %s for writing\n", dev);
                return 0;
        }

        ss0 = ss;
        ct = statbuf.st_size / 516;
        while (ct--) {
                sno = chars_to_ulong(ss);
                if (!sseek(dev, fdout, sno))
                        return 0;
                if (write(fdout, ss + 4, 512) != 512) {
                        perror(dev);
                        errorMsg("error writing sector %lu on %s\n", sno, dev);
                        return 0;
                }
                ss += 516;
        }
        free(ss0);

        reread_disk_partition(dev, fdout);

        return 1;
}

/*
 *  C. About heads, sectors and cylinders
 */

/*
 * <linux/hdreg.h> defines HDIO_GETGEO and
 * struct hd_geometry {
 *      unsigned char heads;
 *      unsigned char sectors;
 *      unsigned short cylinders;
 *      unsigned long start;
 * };
 */

/*
 * We consider several geometries for a disk:
 * B - the BIOS geometry, gotten from the kernel via HDIO_GETGEO
 * F - the fdisk geometry
 * U - the user-specified geometry
 *
 * 0 means unspecified / unknown
 */
struct geometry {
        unsigned long cylindersize;
        unsigned long heads, sectors, cylinders;
} B, F, U;

static void get_cylindersize(char *dev, int fd, int silent)
{
        struct hd_geometry g;
        int ioctl_ok = 0;

        B.heads = B.sectors = B.cylinders = 0;

        if (!ioctl(fd, HDIO_GETGEO, &g)) {
                ioctl_ok = 1;

                B.heads = g.heads;
                B.sectors = g.sectors;
                B.cylinders = g.cylinders;
        }

        if (U.heads)
                B.heads = U.heads;
        if (U.sectors)
                B.sectors = U.sectors;
        if (U.cylinders)
                B.cylinders = U.cylinders;

        B.cylindersize = B.heads * B.sectors;

        if (ioctl_ok) {
                if (g.start && !force) {
                        warn
                                ("Warning: start=%ld - this looks like a partition rather than\n"
                                 "the entire disk. Using fdisk on it is probably meaningless.\n"
                                 "[Use the --force option if you really want this]\n",
                                 g.start);
                        exit(1);
                }
                if (B.heads != g.heads)
                        warn("Warning: HDIO_GETGEO says that there are %d heads\n",
                                 g.heads);
                if (B.sectors != g.sectors)
                        warn("Warning: HDIO_GETGEO says that there are %d sectors\n",
                                 g.sectors);
                if (B.cylinders != g.cylinders)
                        warn("Warning: HDIO_GETGEO says that there are %d cylinders\n",
                                 g.cylinders);
        } else if (!silent)
                if (!B.heads || !B.sectors || !B.cylinders)
                        printf("Disk %s: cannot get geometry\n", dev);
        if (B.sectors > 63)
                warn
                        ("Warning: unlikely number of sectors (%ld - usually at most 63\n"
                         "This will give problems with all software that uses C/H/S addressing.\n",
                         B.sectors);
        if (!silent)
                printf("\nDisk %s: %lu cylinders, %lu heads, %lu sectors/track\n",
                           dev, B.cylinders, B.heads, B.sectors);
}

typedef struct {
        unsigned char h, s, c;
} chs;                                                  /* has some c bits in s */
static chs zero_chs = { 0, 0, 0 };

typedef struct {
        unsigned long h, s, c;
} longchs;
static longchs zero_longchs;

static chs longchs_to_chs(longchs aa, struct geometry G)
{
        chs a;

        if (aa.h < 256 && aa.s < 64 && aa.c < 1024) {
                a.h = aa.h;
                a.s = aa.s | ((aa.c >> 2) & 0xc0);
                a.c = (aa.c & 0xff);
        } else if (G.heads && G.sectors) {
                a.h = G.heads - 1;
                a.s = G.sectors | 0xc0;
                a.c = 0xff;
        } else
                a = zero_chs;
        return a;
}

static longchs chs_to_longchs(chs a)
{
        longchs aa;

        aa.h = a.h;
        aa.s = (a.s & 0x3f);
        aa.c = (a.s & 0xc0);
        aa.c = (aa.c << 2) + a.c;
        return aa;
}

static longchs ulong_to_longchs(unsigned long sno, struct geometry G)
{
        longchs aa;

        if (G.heads && G.sectors && G.cylindersize) {
                aa.s = 1 + sno % G.sectors;
                aa.h = (sno / G.sectors) % G.heads;
                aa.c = sno / G.cylindersize;
                return aa;
        } else {
                return zero_longchs;
        }
}

//static unsigned long
//longchs_to_ulong (longchs aa, struct geometry G) {
//    return (aa.c*G.cylindersize + aa.h*G.sectors + aa.s - 1);
//}

static chs ulong_to_chs(unsigned long sno, struct geometry G)
{
        return longchs_to_chs(ulong_to_longchs(sno, G), G);
}

//static unsigned long
//chs_to_ulong (chs a, struct geometry G) {
//    return longchs_to_ulong(chs_to_longchs(a), G);
//}

static int is_equal_chs(chs a, chs b)
{
        return (a.h == b.h && a.s == b.s && a.c == b.c);
}

static int chs_ok(chs a, char *v, char *w)
{
        longchs aa = chs_to_longchs(a);
        int ret = 1;

        if (is_equal_chs(a, zero_chs))
                return 1;
        if (B.heads && aa.h >= B.heads) {
                warn("%s of partition %s has impossible value for head: "
                         "%ld (should be in 0-%ld)\n", w, v, aa.h, B.heads - 1);
                ret = 0;
        }
        if (B.sectors && (aa.s == 0 || aa.s > B.sectors)) {
                warn("%s of partition %s has impossible value for sector: "
                         "%ld (should be in 1-%ld)\n", w, v, aa.s, B.sectors);
                ret = 0;
        }
        if (B.cylinders && aa.c >= B.cylinders) {
                warn("%s of partition %s has impossible value for cylinders: "
                         "%ld (should be in 0-%ld)\n", w, v, aa.c, B.cylinders - 1);
                ret = 0;
        }
        return ret;
}

/*
 *  D. About system Ids
 */

#define EMPTY_PARTITION         0
#define EXTENDED_PARTITION      5
#define WIN98_EXTENDED          0x0f
#define DM6_AUX1PARTITION       0x51
#define DM6_AUX3PARTITION       0x53
#define DM6_PARTITION           0x54
#define EZD_PARTITION           0x55
#define LINUX_SWAP              0x82
#define LINUX_NATIVE            0x83
#define LINUX_EXTENDED          0x85
#define BSD_PARTITION           0xa5

/* List of partition types now in i386_sys_types.c */

static const char *sysname(unsigned char type)
{
        struct systypes *s;

        for (s = i386_sys_types; s->name; s++)
                if (s->type == type)
                        return s->name;
        return "Unknown";
}

static void list_types(void)
{
        struct systypes *s;

        printf("Id  Name\n\n");
        for (s = i386_sys_types; s->name; s++)
                printf("%2x  %s\n", s->type, s->name);
}

static int is_extended(unsigned char type)
{
        return (type == EXTENDED_PARTITION
                        || type == LINUX_EXTENDED || type == WIN98_EXTENDED);
}

static int is_bsd(unsigned char type)
{
        return (type == BSD_PARTITION);
}

/*
 *  E. About partitions
 */

/* MS/DOS partition */

struct partition {
        unsigned char bootable;         /* 0 or 0x80 */
        chs begin_chs;
        unsigned char sys_type;
        chs end_chs;
        unsigned int start_sect;        /* starting sector counting from 0 */
        unsigned int nr_sects;          /* nr of sectors in partition */
};

/* Unfortunately, partitions are not aligned, and non-Intel machines
   are unhappy with non-aligned integers. So, we need a copy by hand. */
static int copy_to_int(unsigned char *cp)
{
        unsigned int m;

        m = *cp++;
        m += (*cp++ << 8);
        m += (*cp++ << 16);
        m += (*cp++ << 24);
        return m;
}

static void copy_from_int(int m, char *cp)
{
        *cp++ = (m & 0xff);
        m >>= 8;
        *cp++ = (m & 0xff);
        m >>= 8;
        *cp++ = (m & 0xff);
        m >>= 8;
        *cp++ = (m & 0xff);
}

static void copy_to_part(char *cp, struct partition *p)
{
        p->bootable = *cp++;
        p->begin_chs.h = *cp++;
        p->begin_chs.s = *cp++;
        p->begin_chs.c = *cp++;
        p->sys_type = *cp++;
        p->end_chs.h = *cp++;
        p->end_chs.s = *cp++;
        p->end_chs.c = *cp++;
        p->start_sect = copy_to_int(cp);
        p->nr_sects = copy_to_int(cp + 4);
}

static void copy_from_part(struct partition *p, char *cp)
{
        *cp++ = p->bootable;
        *cp++ = p->begin_chs.h;
        *cp++ = p->begin_chs.s;
        *cp++ = p->begin_chs.c;
        *cp++ = p->sys_type;
        *cp++ = p->end_chs.h;
        *cp++ = p->end_chs.s;
        *cp++ = p->end_chs.c;
        copy_from_int(p->start_sect, cp);
        copy_from_int(p->nr_sects, cp + 4);
}

/* Roughly speaking, Linux doesn't use any of the above fields except
   for partition type, start sector and number of sectors. (However,
   see also linux/drivers/scsi/fdomain.c.)
   The only way partition type is used (in the kernel) is the comparison
   for equality with EXTENDED_PARTITION (and these Disk Manager types). */

struct part_desc {
        unsigned long start;
        unsigned long size;
        unsigned long sector, offset;   /* disk location of this info */
        struct partition p;
        struct part_desc *ep;           /* extended partition containing this one */
        int ptype;
#define DOS_TYPE        0
#define BSD_TYPE        1
} zero_part_desc;

struct part_desc *outer_extended_partition(struct part_desc *p)
{
        while (p->ep)
                p = p->ep;
        return p;
}

static int is_parent(struct part_desc *pp, struct part_desc *p)
{
        while (p) {
                if (pp == p)
                        return 1;
                p = p->ep;
        }
        return 0;
}

struct disk_desc {
        struct part_desc partitions[128];
        int partno;
} oldp, newp;

/* determine where on the disk this information goes */
static void add_sector_and_offset(struct disk_desc *z)
{
        int pno;
        struct part_desc *p;

        for (pno = 0; pno < z->partno; pno++) {
                p = &(z->partitions[pno]);
                p->offset = 0x1be + (pno % 4) * sizeof(struct partition);

                p->sector = (p->ep ? p->ep->start : 0);
        }
}

/* tell the kernel to reread the partition tables */
static int reread_ioctl(int fd)
{
        if (ioctl(fd, BLKRRPART)) {
                perror("BLKRRPART");
                return -1;
        }
        return 0;
}

static int is_blockdev(int fd)
{
        struct stat statbuf;

        return (fstat(fd, &statbuf) == 0 && S_ISBLK(statbuf.st_mode));
}

/* reread after writing */
static void reread_disk_partition(char *dev, int fd)
{
        printf("Re-reading the partition table ...\n");
        fflush(stdout);
        sync();
        sleep(3);                                       /* superfluous since 1.3.20 */

        if (reread_ioctl(fd) && is_blockdev(fd))
                printf("The command to re-read the partition table failed\n"
                           "Reboot your system now, before using mkfs\n");

        if (close(fd)) {
                perror(dev);
                printf("Error closing %s\n", dev);
        }
        printf("\n");
}

/* find Linux name of this partition, assuming that it will have a name */
static int index_to_linux(int pno, struct disk_desc *z)
{
        int i, ct = 1;
        struct part_desc *p = &(z->partitions[0]);

        for (i = 0; i < pno; i++, p++)
                if (i < 4 || (p->size > 0 && !is_extended(p->p.sys_type)))
                        ct++;
        return ct;
}

static int linux_to_index(int lpno, struct disk_desc *z)
{
        int i, ct = 0;
        struct part_desc *p = &(z->partitions[0]);

        for (i = 0; i < z->partno && ct < lpno; i++, p++)
                if ((i < 4 || (p->size > 0 && !is_extended(p->p.sys_type)))
                        && ++ct == lpno)
                        return i;
        return -1;
}

static int asc_to_index(char *pnam, struct disk_desc *z)
{
        int pnum, pno;

        if (*pnam == '#') {
                pno = atoi(pnam + 1);
        } else {
                pnum = atoi(pnam);
                pno = linux_to_index(pnum, z);
        }
        if (!(pno >= 0 && pno < z->partno))
                fatalError("%s: no such partition\n", pnam);
        return pno;
}

/*
 * List partitions - in terms of sectors, blocks or cylinders
 */
#define F_SECTOR   1
#define F_BLOCK    2
#define F_CYLINDER 3
#define F_MEGABYTE 4

static int default_format = F_MEGABYTE;
static int specified_format = 0;
static int show_extended = 0;
static int one_only = 0;
static int one_only_pno;
static int increment = 0;

static void set_format(char c)
{
        switch (c) {
        default:
                printf("unrecognized format - using sectors\n");
        case 'S':
                specified_format = F_SECTOR;
                break;
        case 'B':
                specified_format = F_BLOCK;
                break;
        case 'C':
                specified_format = F_CYLINDER;
                break;
        case 'M':
                specified_format = F_MEGABYTE;
                break;
        }
}

static unsigned long unitsize(int format)
{
        default_format = (B.cylindersize ? F_CYLINDER : F_MEGABYTE);
        if (!format && !(format = specified_format))
                format = default_format;

        switch (format) {
        default:
        case F_CYLINDER:
                if (B.cylindersize)
                        return B.cylindersize;
        case F_SECTOR:
                return 1;
        case F_BLOCK:
                return 2;
        case F_MEGABYTE:
                return 2048;
        }
}

static unsigned long get_disksize(int format)
{
        unsigned long cs = B.cylinders;

        if (cs && leave_last)
                cs--;
        return (cs * B.cylindersize) / unitsize(format);
}

static void out_partition_header(char *dev, int format, struct geometry G)
{
        if (dump) {
                printf("# partition table of %s\n", dev);
                printf("unit: sectors\n\n");
                return;
        }

        default_format = (G.cylindersize ? F_CYLINDER : F_MEGABYTE);
        if (!format && !(format = specified_format))
                format = default_format;

        switch (format) {
        default:
                printf("unimplemented format - using %s\n",
                           G.cylindersize ? "cylinders" : "sectors");
        case F_CYLINDER:
                if (G.cylindersize) {
                        printf("Units = cylinders of %lu bytes, blocks of 1024 bytes"
                                   ", counting from %d\n\n",
                                   G.cylindersize << 9, increment);
                        printf
                                ("   Device Boot Start     End   #cyls   #blocks   Id  System\n");
                        break;
                }
                /* fall through */
        case F_SECTOR:
                printf("Units = sectors of 512 bytes, counting from %d\n\n",
                           increment);
                printf
                        ("   Device Boot    Start       End  #sectors  Id  System\n");
                break;
        case F_BLOCK:
                printf("Units = blocks of 1024 bytes, counting from %d\n\n",
                           increment);
                printf
                        ("   Device Boot   Start       End   #blocks   Id  System\n");
                break;
        case F_MEGABYTE:
                printf("Units = megabytes of 1048576 bytes, blocks of 1024 bytes"
                           ", counting from %d\n\n", increment);
                printf
                        ("   Device Boot Start   End     MB   #blocks   Id  System\n");
                break;
        }
}

static void
out_rounddown(int width, unsigned long n, unsigned long unit, int inc)
{
        printf("%*lu", width, inc + n / unit);
        if (unit != 1)
                putchar((n % unit) ? '+' : ' ');
        putchar(' ');
}

static void
out_roundup(int width, unsigned long n, unsigned long unit, int inc)
{
        if (n == (unsigned long) (-1))
                printf("%*s", width, "-");
        else
                printf("%*lu", width, inc + n / unit);
        if (unit != 1)
                putchar(((n + 1) % unit) ? '-' : ' ');
        putchar(' ');
}

static void
out_roundup_size(int width, unsigned long n, unsigned long unit)
{
        printf("%*lu", width, (n + unit - 1) / unit);
        if (unit != 1)
                putchar((n % unit) ? '-' : ' ');
        putchar(' ');
}

static int get_fdisk_geometry(struct part_desc *p)
{
        chs b = p->p.end_chs;
        longchs bb = chs_to_longchs(b);

        F.heads = bb.h + 1;
        F.sectors = bb.s;
        F.cylindersize = F.heads * F.sectors;
        return (F.sectors != B.sectors || F.heads != B.heads);
}

static void
out_partition(char *dev, int format, struct part_desc *p,
                          struct disk_desc *z, struct geometry G)
{
        unsigned long start, end, size;
        int pno, lpno;

        if (!format && !(format = specified_format))
                format = default_format;

        pno = p - &(z->partitions[0]);  /* our index */
        lpno = index_to_linux(pno, z);  /* name of next one that has a name */
        if (pno == linux_to_index(lpno, z))     /* was that us? */
                printf("%8s%-2u", dev, lpno);   /* yes */
        else if (show_extended)
                printf("    -     ");
        else
                return;
        putchar(dump ? ':' : ' ');

        start = p->start;
        end = p->start + p->size - 1;
        size = p->size;

        if (dump) {
                printf(" start=%9lu", start);
                printf(", size=%8lu", size);
                if (p->ptype == DOS_TYPE) {
                        printf(", Id=%2x", p->p.sys_type);
                        if (p->p.bootable == 0x80)
                                printf(", bootable");
                }
                printf("\n");
                return;
        }

        if (p->ptype != DOS_TYPE || p->p.bootable == 0)
                printf("   ");
        else if (p->p.bootable == 0x80)
                printf(" * ");
        else
                printf(" ? ");                  /* garbage */

        switch (format) {
        case F_CYLINDER:
                if (G.cylindersize) {
                        out_rounddown(6, start, G.cylindersize, increment);
                        out_roundup(6, end, G.cylindersize, increment);
                        out_roundup_size(6, size, G.cylindersize);
                        out_rounddown(8, size, 2, 0);
                        break;
                }
                /* fall through */
        default:
        case F_SECTOR:
                out_rounddown(9, start, 1, increment);
                out_roundup(9, end, 1, increment);
                out_rounddown(9, size, 1, 0);
                break;
        case F_BLOCK:
#if 0
                printf("%8lu,%3lu ",
                           p->sector / 2, ((p->sector & 1) ? 512 : 0) + p->offset);
#endif
                out_rounddown(8, start, 2, increment);
                out_roundup(8, end, 2, increment);
                out_rounddown(8, size, 2, 0);
                break;
        case F_MEGABYTE:
                out_rounddown(5, start, 2048, increment);
                out_roundup(5, end, 2048, increment);
                out_roundup_size(5, size, 2048);
                out_rounddown(8, size, 2, 0);
                break;
        }
        if (p->ptype == DOS_TYPE) {
                printf(" %2x  %s\n", p->p.sys_type, sysname(p->p.sys_type));
        } else {
                printf("\n");
        }

        /* Is chs as we expect? */
        if (!quiet && p->ptype == DOS_TYPE) {
                chs a, b;
                longchs aa, bb;

                a = (size ? ulong_to_chs(start, G) : zero_chs);
                b = p->p.begin_chs;
                aa = chs_to_longchs(a);
                bb = chs_to_longchs(b);
                if (a.s && !is_equal_chs(a, b))
                        printf
                                ("\t\tstart: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n",
                                 aa.c, aa.h, aa.s, bb.c, bb.h, bb.s);
                a = (size ? ulong_to_chs(end, G) : zero_chs);
                b = p->p.end_chs;
                aa = chs_to_longchs(a);
                bb = chs_to_longchs(b);
                if (a.s && !is_equal_chs(a, b))
                        printf
                                ("\t\tend: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n",
                                 aa.c, aa.h, aa.s, bb.c, bb.h, bb.s);
                if (G.cylinders && G.cylinders < 1024 && bb.c > G.cylinders)
                        printf
                                ("partition ends on cylinder %ld, beyond the end of the disk\n",
                                 bb.c);
        }
}

static void out_partitions(char *dev, struct disk_desc *z)
{
        struct part_desc *p;
        int pno, format = 0;

        if (z->partno == 0)
                printf("No partitions found\n");
        else {
                for (pno = 0; pno < z->partno; pno++) {
                        p = &(z->partitions[pno]);
                        if (p->size != 0 && p->p.sys_type != 0) {
                                if (get_fdisk_geometry(p))
                                        printf
                                                ("Warning: The first partition looks like it was made\n"
                                                 "  for C/H/S=*/%ld/%ld (instead of %ld/%ld/%ld).\n"
                                                 "For this listing I'll assume that geometry.\n",
                                                 F.heads, F.sectors, B.cylinders, B.heads,
                                                 B.sectors);
                                break;
                        }
                }
                out_partition_header(dev, format, F);
                for (pno = 0; pno < z->partno; pno++) {
                        out_partition(dev, format, &(z->partitions[pno]), z, F);
                        if (show_extended && pno % 4 == 3)
                                printf("\n");
                }
        }
}

static int disj(struct part_desc *p, struct part_desc *q)
{
        return ((p->start + p->size <= q->start)
                        || (is_extended(p->p.sys_type)
                                && q->start + q->size <= p->start + p->size));
}

static char *pnumber(struct part_desc *p, struct disk_desc *z)
{
        static char buf[20];
        int this, next;
        struct part_desc *p0 = &(z->partitions[0]);

        this = index_to_linux(p - p0, z);
        next = index_to_linux(p - p0 + 1, z);

        if (next > this)
                sprintf(buf, "%d", this);
        else
                sprintf(buf, "[%d]", this);
        return buf;
}

static int partitions_ok(struct disk_desc *z)
{
        struct part_desc *partitions = &(z->partitions[0]), *p, *q;
        int partno = z->partno;

#define PNO(p) pnumber(p, z)

        /* Have at least 4 partitions been defined? */
        if (partno < 4) {
                if (!partno)
                        fatalError("no partition table present.\n");
                else
                        fatalError("strange, only %d partitions defined.\n", partno);
                return 0;
        }

        /* Are the partitions of size 0 marked empty?
           And do they have start = 0? And bootable = 0? */
        for (p = partitions; p - partitions < partno; p++)
                if (p->size == 0) {
                        if (p->p.sys_type != EMPTY_PARTITION)
                                warn
                                        ("Warning: partition %s has size 0 but is not marked Empty\n",
                                         PNO(p));
                        else if (p->p.bootable != 0)
                                warn("Warning: partition %s has size 0 and is bootable\n",
                                         PNO(p));
                        else if (p->p.start_sect != 0)
                                warn
                                        ("Warning: partition %s has size 0 and nonzero start\n",
                                         PNO(p));
                        /* all this is probably harmless, no error return */
                }

        /* Are the logical partitions contained in their extended partitions? */
        for (p = partitions + 4; p < partitions + partno; p++)
                if (p->ptype == DOS_TYPE)
                        if (p->size && !is_extended(p->p.sys_type)) {
                                q = p->ep;
                                if (p->start < q->start
                                        || p->start + p->size > q->start + q->size) {
                                        warn("Warning: partition %s ", PNO(p));
                                        warn("is not contained in partition %s\n", PNO(q));
                                        return 0;
                                }
                        }

        /* Are the data partitions mutually disjoint? */
        for (p = partitions; p < partitions + partno; p++)
                if (p->size && !is_extended(p->p.sys_type))
                        for (q = p + 1; q < partitions + partno; q++)
                                if (q->size && !is_extended(q->p.sys_type))
                                        if (!((p->start > q->start) ? disj(q, p) : disj(p, q))) {
                                                warn("Warning: partitions %s ", PNO(p));
                                                warn("and %s overlap\n", PNO(q));
                                                return 0;
                                        }

        /* Are the data partitions and the extended partition
           table sectors disjoint? */
        for (p = partitions; p < partitions + partno; p++)
                if (p->size && !is_extended(p->p.sys_type))
                        for (q = partitions; q < partitions + partno; q++)
                                if (is_extended(q->p.sys_type))
                                        if (p->start <= q->start
                                                && p->start + p->size > q->start) {
                                                warn("Warning: partition %s contains part of ",
                                                         PNO(p));
                                                warn("the partition table (sector %lu),\n",
                                                         q->start);
                                                warn("and will destroy it when filled\n");
                                                return 0;
                                        }

        /* Do they start past zero and end before end-of-disk? */
        {
                unsigned long ds = get_disksize(F_SECTOR);

                for (p = partitions; p < partitions + partno; p++)
                        if (p->size) {
                                if (p->start == 0) {
                                        warn("Warning: partition %s starts at sector 0\n",
                                                 PNO(p));
                                        return 0;
                                }
                                if (p->size && p->start + p->size > ds) {
                                        warn
                                                ("Warning: partition %s extends past end of disk\n",
                                                 PNO(p));
                                        return 0;
                                }
                        }
        }

        /* At most one chain of DOS extended partitions ? */
        /* It seems that the OS/2 fdisk has the additional requirement
           that the extended partition must be the fourth one */
        {
                int ect = 0;

                for (p = partitions; p < partitions + 4; p++)
                        if (p->p.sys_type == EXTENDED_PARTITION)
                                ect++;
                if (ect > 1 && !Linux) {
                        warn
                                ("Among the primary partitions, at most one can be extended\n");
                        warn(" (although this is not a problem under Linux)\n");
                        return 0;
                }
        }

        /*
         * Do all partitions start at a cylinder boundary ?
         * (this is not required for Linux)
         * The first partition starts after MBR.
         * Logical partitions start slightly after the containing extended partn.
         */
        if (B.cylindersize) {
                for (p = partitions; p < partitions + partno; p++)
                        if (p->size) {
                                if (p->start % B.cylindersize != 0
                                        && (!p->ep
                                                || p->start / B.cylindersize !=
                                                p->ep->start / B.cylindersize)
                                        && (p->p.start_sect >= B.cylindersize)) {
                                        warn("Warning: partition %s does not start "
                                                 "at a cylinder boundary\n", PNO(p));
                                        if (!Linux)
                                                return 0;
                                }
                                if ((p->start + p->size) % B.cylindersize) {
                                        warn("Warning: partition %s does not end "
                                                 "at a cylinder boundary\n", PNO(p));
                                        if (!Linux)
                                                return 0;
                                }
                        }
        }

        /* Usually, one can boot only from primary partitions. */
        /* In fact, from a unique one only. */
        /* do not warn about bootable extended partitions -
           often LILO is there */
        {
                int pno = -1;

                for (p = partitions; p < partitions + partno; p++)
                        if (p->p.bootable) {
                                if (pno == -1)
                                        pno = p - partitions;
                                else if (p - partitions < 4) {
                                        warn
                                                ("Warning: more than one primary partition is marked "
                                                 "bootable (active)\n"
                                                 "This does not matter for LILO, but the DOS MBR will "
                                                 "not boot this disk.\n");
                                        break;
                                }
                                if (p - partitions >= 4) {
                                        warn
                                                ("Warning: usually one can boot from primary partitions "
                                                 "only\nLILO disregards the `bootable' flag.\n");
                                        break;
                                }
                        }
                if (pno == -1 || pno >= 4)
                        warn
                                ("Warning: no primary partition is marked bootable (active)\n"
                                 "This does not matter for LILO, but the DOS MBR will "
                                 "not boot this disk.\n");
        }

        /* Is chs as we expect? */
        for (p = partitions; p < partitions + partno; p++)
                if (p->ptype == DOS_TYPE) {
                        chs a, b;
                        longchs aa, bb;

                        a = p->size ? ulong_to_chs(p->start, B) : zero_chs;
                        b = p->p.begin_chs;
                        aa = chs_to_longchs(a);
                        bb = chs_to_longchs(b);
                        if (!chs_ok(b, PNO(p), "start"))
                                return 0;
                        if (a.s && !is_equal_chs(a, b))
                                warn
                                        ("partition %s: start: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n",
                                         PNO(p), aa.c, aa.h, aa.s, bb.c, bb.h, bb.s);
                        a =
                                p->size ? ulong_to_chs(p->start + p->size - 1,
                                                                           B) : zero_chs;
                        b = p->p.end_chs;
                        aa = chs_to_longchs(a);
                        bb = chs_to_longchs(b);
                        if (!chs_ok(b, PNO(p), "end"))
                                return 0;
                        if (a.s && !is_equal_chs(a, b))
                                warn
                                        ("partition %s: end: (c,h,s) expected (%ld,%ld,%ld) found (%ld,%ld,%ld)\n",
                                         PNO(p), aa.c, aa.h, aa.s, bb.c, bb.h, bb.s);
                        if (B.cylinders && B.cylinders < 1024 && bb.c > B.cylinders)
                                warn
                                        ("partition %s ends on cylinder %ld, beyond the end of the disk\n",
                                         PNO(p), bb.c);
                }

        return 1;

#undef PNO
}

static void
extended_partition(char *dev, int fd, struct part_desc *ep,
                                   struct disk_desc *z)
{
        char *cp;
        struct sector *s;
        unsigned long start, here, next;
        int i, moretodo = 1;
        struct partition p;
        struct part_desc *partitions = &(z->partitions[0]);
        int pno = z->partno;

        here = start = ep->start;

        while (moretodo) {
                moretodo = 0;

                if (!(s = get_sector(dev, fd, here)))
                        break;

                if (!msdos_signature(s))
                        break;

                cp = s->data + 0x1be;

                if (pno + 4 >= SIZE(z->partitions)) {
                        printf("too many partitions - ignoring those past nr (%d)\n",
                                   pno - 1);
                        break;
                }

                next = 0;

                for (i = 0; i < 4; i++, cp += sizeof(struct partition)) {
                        partitions[pno].sector = here;
                        partitions[pno].offset = cp - s->data;
                        partitions[pno].ep = ep;
                        copy_to_part(cp, &p);
                        if (is_extended(p.sys_type)) {
                                partitions[pno].start = start + p.start_sect;
                                if (next)
                                        printf("tree of partitions?\n");
                                else
                                        next = partitions[pno].start;   /* follow `upper' branch */
                                moretodo = 1;
                        } else {
                                partitions[pno].start = here + p.start_sect;
                        }
                        partitions[pno].size = p.nr_sects;
                        partitions[pno].ptype = DOS_TYPE;
                        partitions[pno].p = p;
                        pno++;
                }
                here = next;
        }

        z->partno = pno;
}

#define BSD_DISKMAGIC   (0x82564557UL)
#define BSD_MAXPARTITIONS       8
#define BSD_FS_UNUSED           0
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
struct bsd_disklabel {
        u32 d_magic;
        char d_junk1[4];
        char d_typename[16];
        char d_packname[16];
        char d_junk2[92];
        u32 d_magic2;
        char d_junk3[2];
        u16 d_npartitions;                      /* number of partitions in following */
        char d_junk4[8];
        struct bsd_partition {          /* the partition table */
                u32 p_size;                             /* number of sectors in partition */
                u32 p_offset;                   /* starting sector */
                u32 p_fsize;                    /* filesystem basic fragment size */
                u8 p_fstype;                    /* filesystem type, see below */
                u8 p_frag;                              /* filesystem fragments per block */
                u16 p_cpg;                              /* filesystem cylinders per group */
        } d_partitions[BSD_MAXPARTITIONS];      /* actually may be more */
};

static void
bsd_partition(char *dev, int fd, struct part_desc *ep, struct disk_desc *z)
{
        struct bsd_disklabel *l;
        struct bsd_partition *bp, *bp0;
        unsigned long start = ep->start;
        struct sector *s;
        struct part_desc *partitions = &(z->partitions[0]);
        int pno = z->partno;

        if (!(s = get_sector(dev, fd, start + 1)))
                return;
        l = (struct bsd_disklabel *) (s->data);
        if (l->d_magic != BSD_DISKMAGIC)
                return;

        bp = bp0 = &l->d_partitions[0];
        while (bp - bp0 <= BSD_MAXPARTITIONS) {
                if (pno + 1 >= SIZE(z->partitions)) {
                        printf("too many partitions - ignoring those "
                                   "past nr (%d)\n", pno - 1);
                        break;
                }
                if (bp->p_fstype != BSD_FS_UNUSED) {
                        partitions[pno].start = bp->p_offset;
                        partitions[pno].size = bp->p_size;
                        partitions[pno].sector = start + 1;
                        partitions[pno].offset = (char *) bp - (char *) bp0;
                        partitions[pno].ep = 0;
                        partitions[pno].ptype = BSD_TYPE;
                        pno++;
                }
                bp++;
        }
        z->partno = pno;
}

static int
msdos_partition(char *dev, int fd, unsigned long start,
                                struct disk_desc *z)
{
        int i;
        char *cp;
        struct partition pt;
        struct sector *s;
        struct part_desc *partitions = &(z->partitions[0]);
        int pno = z->partno;

        if (!(s = get_sector(dev, fd, start)))
                return 0;

        if (!msdos_signature(s))
                return 0;

        cp = s->data + 0x1be;
        copy_to_part(cp, &pt);

        /* If I am not mistaken, recent kernels will hide this from us,
           so we will never actually see traces of a Disk Manager */
        if (pt.sys_type == DM6_PARTITION
                || pt.sys_type == EZD_PARTITION
                || pt.sys_type == DM6_AUX1PARTITION
                || pt.sys_type == DM6_AUX3PARTITION) {
                printf("detected Disk Manager - unable to handle that\n");
                return 0;
        }
        {
                unsigned int sig = *(unsigned short *) (s->data + 2);

                if (sig <= 0x1ae
                        && *(unsigned short *) (s->data + sig) == 0x55aa
                        && (1 & *(unsigned char *) (s->data + sig + 2))) {
                        printf("DM6 signature found - giving up\n");
                        return 0;
                }
        }

        for (pno = 0; pno < 4; pno++, cp += sizeof(struct partition)) {
                partitions[pno].sector = start;
                partitions[pno].offset = cp - s->data;
                copy_to_part(cp, &pt);
                partitions[pno].start = start + pt.start_sect;
                partitions[pno].size = pt.nr_sects;
                partitions[pno].ep = 0;
                partitions[pno].p = pt;
        }

        z->partno = pno;

        for (i = 0; i < 4; i++) {
                if (is_extended(partitions[i].p.sys_type)) {
                        if (!partitions[i].size) {
                                printf("strange..., an extended partition of size 0?\n");
                                continue;
                        }
                        extended_partition(dev, fd, &partitions[i], z);
                }
                if (is_bsd(partitions[i].p.sys_type)) {
                        if (!partitions[i].size) {
                                printf("strange..., a BSD partition of size 0?\n");
                                continue;
                        }
                        bsd_partition(dev, fd, &partitions[i], z);
                }
        }
        return 1;
}

static int
osf_partition(char *dev, int fd, unsigned long start, struct disk_desc *z)
{
        return 0;
}

static int
sun_partition(char *dev, int fd, unsigned long start, struct disk_desc *z)
{
        return 0;
}

static int
amiga_partition(char *dev, int fd, unsigned long start,
                                struct disk_desc *z)
{
        return 0;
}

static void get_partitions(char *dev, int fd, struct disk_desc *z)
{
        z->partno = 0;

        if (!msdos_partition(dev, fd, 0, z)
                && !osf_partition(dev, fd, 0, z)
                && !sun_partition(dev, fd, 0, z)
                && !amiga_partition(dev, fd, 0, z)) {
                printf(" %s: unrecognized partition\n", dev);
                return;
        }
}

static int write_partitions(char *dev, int fd, struct disk_desc *z)
{
        struct sector *s;
        struct part_desc *partitions = &(z->partitions[0]), *p;
        int pno = z->partno;

        if (no_write) {
                printf("-n flag was given: Nothing changed\n");
                exit(0);
        }

        for (p = partitions; p < partitions + pno; p++) {
                s = get_sector(dev, fd, p->sector);
                if (!s)
                        return 0;
                s->to_be_written = 1;
                copy_from_part(&(p->p), s->data + p->offset);
                *(unsigned short *) (&(s->data[0x1fe])) = 0xaa55;
        }
        if (save_sector_file) {
                if (!save_sectors(dev, fd)) {
                        fatalError("Failed saving the old sectors - aborting\n");
                        return 0;
                }
        }
        if (!write_sectors(dev, fd)) {
                errorMsg("Failed writing the partition on %s\n", dev);
                return 0;
        }
        return 1;
}

/*
 *  F. The standard input
 */

/*
 * Input format:
 * <start> <size> <type> <bootable> <c,h,s> <c,h,s>
 * Fields are separated by whitespace or comma or semicolon possibly
 * followed by whitespace; initial and trailing whitespace is ignored.
 * Numbers can be octal, decimal or hexadecimal, decimal is default
 * The <c,h,s> parts can (and probably should) be omitted.
 * Bootable is specified as [*|-], with as default not-bootable.
 * Type is given in hex, without the 0x prefix, or is [E|S|L|X], where
 * L (LINUX_NATIVE (83)) is the default, S is LINUX_SWAP (82), and E
 * is EXTENDED_PARTITION (5), X is LINUX_EXTENDED (85).
 * The default value of start is the first nonassigned sector/cylinder/...
 * The default value of size is as much as possible (until next
 * partition or end-of-disk).
 * .: end of chain of extended partitions.
 *
 * On interactive input an empty line means: all defaults.
 * Otherwise empty lines are ignored.
 */

static int eof, eob;

struct dumpfld {
        int fldno;
        char *fldname;
        int is_bool;
} dumpflds[] = {
        {
        0, "start", 0}, {
        1, "size", 0}, {
        2, "Id", 0}, {
        3, "bootable", 1}, {
        4, "bh", 0}, {
        5, "bs", 0}, {
        6, "bc", 0}, {
        7, "eh", 0}, {
        8, "es", 0}, {
        9, "ec", 0}
};

/*
 * Read a line, split it into fields
 *
 * (some primitive handwork, but a more elaborate parser seems
 *  unnecessary)
 */
#define RD_EOF (-1)
#define RD_CMD (-2)

static int
read_stdin(unsigned char **fields, unsigned char *line, int fieldssize,
                   int linesize)
{
        unsigned char *lp, *ip;
        int c, fno;

        /* boolean true and empty string at start */
        line[0] = '*';
        line[1] = 0;
        for (fno = 0; fno < fieldssize; fno++)
                fields[fno] = line + 1;
        fno = 0;

        /* read a line from stdin */
        lp = fgets(line + 2, linesize, stdin);
        if (lp == NULL) {
                eof = 1;
                return RD_EOF;
        }
        if (!(lp = index(lp, '\n')))
                fatalError("long or incomplete input line - quitting\n");
        *lp = 0;

        /* remove comments, if any */
        if ((lp = index(line + 2, '#')) != 0)
                *lp = 0;

        /* recognize a few commands - to be expanded */
        if (!strcmp(line + 2, "unit: sectors")) {
                specified_format = F_SECTOR;
                return RD_CMD;
        }

        /* dump style? - then bad input is fatal */
        if ((ip = index(line + 2, ':')) != 0) {
                struct dumpfld *d;

          nxtfld:
                ip++;
                while (isspace(*ip))
                        ip++;
                if (*ip == 0)
                        return fno;
                for (d = dumpflds; d - dumpflds < SIZE(dumpflds); d++) {
                        if (!strncmp(ip, d->fldname, strlen(d->fldname))) {
                                ip += strlen(d->fldname);
                                while (isspace(*ip))
                                        ip++;
                                if (d->is_bool)
                                        fields[d->fldno] = line;
                                else if (*ip == '=') {
                                        while (isspace(*++ip));
                                        fields[d->fldno] = ip;
                                        while (isalnum(*ip))    /* 0x07FF */
                                                ip++;
                                } else
                                        fatalError("input error: `=' expected after %s field\n",
                                                  d->fldname);
                                if (fno <= d->fldno)
                                        fno = d->fldno + 1;
                                if (*ip == 0)
                                        return fno;
                                if (*ip != ',' && *ip != ';')
                                        fatalError
                                                ("input error: unexpected character %c after %s field\n",
                                                 *ip, d->fldname);
                                *ip = 0;
                                goto nxtfld;
                        }
                }
                fatalError("unrecognized input: %s\n", ip);
        }

        /* split line into fields */
        lp = ip = line + 2;
        fields[fno++] = lp;
        while ((c = *ip++) != 0) {
                if (!lp[-1] && (c == '\t' || c == ' '));
                else if (c == '\t' || c == ' ' || c == ',' || c == ';') {
                        *lp++ = 0;
                        if (fno < fieldssize)
                                fields[fno++] = lp;
                        continue;
                } else
                        *lp++ = c;
        }

        if (lp == fields[fno - 1])
                fno--;
        return fno;
}

/* read a number, use default if absent */
static int get_ul(char *u, unsigned long *up, unsigned long def, int base)
{
        char *nu;

        if (*u) {
                errno = 0;
                *up = strtoul(u, &nu, base);
                if (errno == ERANGE) {
                        printf("number too big\n");
                        return -1;
                }
                if (*nu) {
                        printf("trailing junk after number\n");
                        return -1;
                }
        } else
                *up = def;
        return 0;
}

/* There are two common ways to structure extended partitions:
   as nested boxes, and as a chain. Sometimes the partitions
   must be given in order. Sometimes all logical partitions
   must lie inside the outermost extended partition.
NESTED: every partition is contained in the surrounding partitions
   and is disjoint from all others.
CHAINED: every data partition is contained in the surrounding partitions
   and disjoint from all others, but extended partitions may lie outside
   (insofar as allowed by all_logicals_inside_outermost_extended).
ONESECTOR: all data partitions are mutually disjoint; extended partitions
   each use one sector only (except perhaps for the outermost one).
*/
static int partitions_in_order = 0;
static int all_logicals_inside_outermost_extended = 1;
static enum { NESTED, CHAINED, ONESECTOR } boxes = NESTED;

/* find the default value for <start> - assuming entire units */
static unsigned long
first_free(int pno, int is_extended, struct part_desc *ep, int format,
                   unsigned long mid, struct disk_desc *z)
{
        unsigned long ff, fff;
        unsigned long unit = unitsize(format);
        struct part_desc *partitions = &(z->partitions[0]), *pp = 0;

        /* if containing ep undefined, look at its container */
        if (ep && ep->p.sys_type == EMPTY_PARTITION)
                ep = ep->ep;

        if (ep) {
                if (boxes == NESTED || (boxes == CHAINED && !is_extended))
                        pp = ep;
                else if (all_logicals_inside_outermost_extended)
                        pp = outer_extended_partition(ep);
        }
#if 0
        ff = pp ? (pp->start + unit - 1) / unit : 0;
#else
        /* rounding up wastes almost an entire cylinder - round down
           and leave it to compute_start_sect() to fix the difference */
        ff = pp ? pp->start / unit : 0;
#endif
        /* MBR and 1st sector of an extended partition are never free */
        if (unit == 1)
                ff++;

  again:
        for (pp = partitions; pp < partitions + pno; pp++) {
                if (!is_parent(pp, ep) && pp->size > 0) {
                        if ((partitions_in_order || pp->start / unit <= ff
                                 || (mid && pp->start / unit <= mid))
                                && (fff = (pp->start + pp->size + unit - 1) / unit) > ff) {
                                ff = fff;
                                goto again;
                        }
                }
        }

        return ff;
}

/* find the default value for <size> - assuming entire units */
static unsigned long
max_length(int pno, int is_extended, struct part_desc *ep, int format,
                   unsigned long start, struct disk_desc *z)
{
        unsigned long fu;
        unsigned long unit = unitsize(format);
        struct part_desc *partitions = &(z->partitions[0]), *pp = 0;

        /* if containing ep undefined, look at its container */
        if (ep && ep->p.sys_type == EMPTY_PARTITION)
                ep = ep->ep;

        if (ep) {
                if (boxes == NESTED || (boxes == CHAINED && !is_extended))
                        pp = ep;
                else if (all_logicals_inside_outermost_extended)
                        pp = outer_extended_partition(ep);
        }
        fu = pp ? (pp->start + pp->size) / unit : get_disksize(format);

        for (pp = partitions; pp < partitions + pno; pp++)
                if (!is_parent(pp, ep) && pp->size > 0
                        && pp->start / unit >= start && pp->start / unit < fu)
                        fu = pp->start / unit;

        return (fu > start) ? fu - start : 0;
}

/* compute starting sector of a partition inside an extended one */
/* ep is 0 or points to surrounding extended partition */
static int compute_start_sect(struct part_desc *p, struct part_desc *ep)
{
        unsigned long base;
        int inc = (DOS && B.sectors) ? B.sectors : 1;
        int delta;

        if (ep && p->start + p->size >= ep->start + 1)
                delta = p->start - ep->start - inc;
        else if (p->start == 0 && p->size > 0)
                delta = -inc;
        else
                delta = 0;
        if (delta < 0) {
                p->start -= delta;
                p->size += delta;
                if (is_extended(p->p.sys_type) && boxes == ONESECTOR)
                        p->size = inc;
                else if ((int) (p->size) <= 0) {
                        warn("no room for partition descriptor\n");
                        return 0;
                }
        }
        base = (!ep ? 0
                        : (is_extended(p->p.sys_type) ?
                           outer_extended_partition(ep) : ep)->start);
        p->ep = ep;
        if (p->p.sys_type == EMPTY_PARTITION && p->size == 0) {
                p->p.start_sect = 0;
                p->p.begin_chs = zero_chs;
                p->p.end_chs = zero_chs;
        } else {
                p->p.start_sect = p->start - base;
                p->p.begin_chs = ulong_to_chs(p->start, B);
                p->p.end_chs = ulong_to_chs(p->start + p->size - 1, B);
        }
        p->p.nr_sects = p->size;
        return 1;
}

/* build the extended partition surrounding a given logical partition */
static int
build_surrounding_extended(struct part_desc *p, struct part_desc *ep,
                                                   struct disk_desc *z)
{
        int inc = (DOS && B.sectors) ? B.sectors : 1;
        int format = F_SECTOR;
        struct part_desc *p0 = &(z->partitions[0]), *eep = ep->ep;

        if (boxes == NESTED) {
                ep->start = first_free(ep - p0, 1, eep, format, p->start, z);
                ep->size = max_length(ep - p0, 1, eep, format, ep->start, z);
                if (ep->start > p->start
                        || ep->start + ep->size < p->start + p->size) {
                        warn("cannot build surrounding extended partition\n");
                        return 0;
                }
        } else {
                ep->start = p->start;
                if (boxes == CHAINED)
                        ep->size = p->size;
                else
                        ep->size = inc;
        }

        ep->p.nr_sects = ep->size;
        ep->p.bootable = 0;
        ep->p.sys_type = EXTENDED_PARTITION;
        if (!compute_start_sect(ep, eep) || !compute_start_sect(p, ep)) {
                ep->p.sys_type = EMPTY_PARTITION;
                ep->size = 0;
                return 0;
        }

        return 1;
}

static int
read_line(int pno, struct part_desc *ep, char *dev, int interactive,
                  struct disk_desc *z)
{
        unsigned char line[1000];
        unsigned char *fields[11];
        int fno, pct = pno % 4;
        struct part_desc p, *orig;
        unsigned long ff, ff1, ul, ml, ml1, def;
        int format, lpno, is_extd;

        if (eof || eob)
                return -1;

        lpno = index_to_linux(pno, z);

        if (interactive) {
                if (pct == 0 && (show_extended || pno == 0))
                        warn("\n");
                warn("%8s%d: ", dev, lpno);
        }

        /* read input line - skip blank lines when reading from a file */
        do {
                fno = read_stdin(fields, line, SIZE(fields), SIZE(line));
        } while (fno == RD_CMD || (fno == 0 && !interactive));
        if (fno == RD_EOF) {
                return -1;
        } else if (fno > 10 && *(fields[10]) != 0) {
                printf("too many input fields\n");
                return 0;
        }

        if (fno == 1 && !strcmp(fields[0], ".")) {
                eob = 1;
                return -1;
        }

        /* use specified format, but round to cylinders if F_MEGABYTE specified */
        format = 0;
        if (B.cylindersize && specified_format == F_MEGABYTE)
                format = F_CYLINDER;

        orig = (one_only ? &(oldp.partitions[pno]) : 0);

        p = zero_part_desc;
        p.ep = ep;

        /* first read the type - we need to know whether it is extended */
        /* stop reading when input blank (defaults) and all is full */
        is_extd = 0;
        if (fno == 0) {                         /* empty line */
                if (orig && is_extended(orig->p.sys_type))
                        is_extd = 1;
                ff = first_free(pno, is_extd, ep, format, 0, z);
                ml = max_length(pno, is_extd, ep, format, ff, z);
                if (ml == 0 && is_extd == 0) {
                        is_extd = 1;
                        ff = first_free(pno, is_extd, ep, format, 0, z);
                        ml = max_length(pno, is_extd, ep, format, ff, z);
                }
                if (ml == 0 && pno >= 4) {
                        /* no free blocks left - don't read any further */
                        warn("No room for more\n");
                        return -1;
                }
        }
        if (fno < 3 || !*(fields[2]))
                ul = orig ? orig->p.sys_type :
                        (is_extd || (pno > 3 && pct == 1 && show_extended))
                        ? EXTENDED_PARTITION : LINUX_NATIVE;
        else if (!strcmp(fields[2], "L"))
                ul = LINUX_NATIVE;
        else if (!strcmp(fields[2], "S"))
                ul = LINUX_SWAP;
        else if (!strcmp(fields[2], "E"))
                ul = EXTENDED_PARTITION;
        else if (!strcmp(fields[2], "X"))
                ul = LINUX_EXTENDED;
        else if (get_ul(fields[2], &ul, LINUX_NATIVE, 16))
                return 0;
        if (ul > 255) {
                warn("Illegal type\n");
                return 0;
        }
        p.p.sys_type = ul;
        is_extd = is_extended(ul);

        /* find start */
        ff = first_free(pno, is_extd, ep, format, 0, z);
        ff1 = ff * unitsize(format);
        def = orig ? orig->start : (pno > 4 && pct > 1) ? 0 : ff1;
        if (fno < 1 || !*(fields[0]))
                p.start = def;
        else {
                if (get_ul(fields[0], &ul, def / unitsize(0), 0))
                        return 0;
                p.start = ul * unitsize(0);
                p.start -= (p.start % unitsize(format));
        }

        /* find length */
        ml =
                max_length(pno, is_extd, ep, format, p.start / unitsize(format),
                                   z);
        ml1 = ml * unitsize(format);
        def = orig ? orig->size : (pno > 4 && pct > 1) ? 0 : ml1;
        if (fno < 2 || !*(fields[1]))
                p.size = def;
        else {
                if (get_ul(fields[1], &ul, def / unitsize(0), 0))
                        return 0;
                p.size = ul * unitsize(0) + unitsize(format) - 1;
                p.size -= (p.size % unitsize(format));
        }
        if (p.size > ml1) {
                warn("Warning: exceeds max allowable size (%lu)\n",
                         ml1 / unitsize(0));
                if (!force)
                        return 0;
        }
        if (p.size == 0 && pno >= 4 && (fno < 2 || !*(fields[1]))) {
                warn("Warning: empty partition\n");
                if (!force)
                        return 0;
        }
        p.p.nr_sects = p.size;

        if (p.size == 0 && !orig) {
                if (fno < 1 || !*(fields[0]))
                        p.start = 0;
                if (fno < 3 || !*(fields[2]))
                        p.p.sys_type = EMPTY_PARTITION;
        }

        if (p.start < ff1 && p.size > 0) {
                warn("Warning: bad partition start (earliest %lu)\n",
                         (ff1 + unitsize(0) - 1) / unitsize(0));
                if (!force)
                        return 0;
        }

        if (fno < 4 || !*(fields[3]))
                ul = (orig ? orig->p.bootable : 0);
        else if (!strcmp(fields[3], "-"))
                ul = 0;
        else if (!strcmp(fields[3], "*") || !strcmp(fields[3], "+"))
                ul = 0x80;
        else {
                warn("unrecognized bootable flag - choose - or *\n");
                return 0;
        }
        p.p.bootable = ul;

        if (ep && ep->p.sys_type == EMPTY_PARTITION) {
                if (!build_surrounding_extended(&p, ep, z))
                        return 0;
        } else if (!compute_start_sect(&p, ep))
                return 0;

        {
                longchs aa = chs_to_longchs(p.p.begin_chs), bb;

                if (fno < 5) {
                        bb = aa;
                } else if (fno < 7) {
                        warn("partial c,h,s specification?\n");
                        return 0;
                } else if (get_ul(fields[4], &bb.c, aa.c, 0) ||
                                   get_ul(fields[5], &bb.h, aa.h, 0) ||
                                   get_ul(fields[6], &bb.s, aa.s, 0))
                        return 0;
                p.p.begin_chs = longchs_to_chs(bb, B);
        }
        {
                longchs aa = chs_to_longchs(p.p.end_chs), bb;

                if (fno < 8) {
                        bb = aa;
                } else if (fno < 10) {
                        warn("partial c,h,s specification?\n");
                        return 0;
                } else if (get_ul(fields[7], &bb.c, aa.c, 0) ||
                                   get_ul(fields[8], &bb.h, aa.h, 0) ||
                                   get_ul(fields[9], &bb.s, aa.s, 0))
                        return 0;
                p.p.end_chs = longchs_to_chs(bb, B);
        }

        if (pno > 3 && p.size && show_extended
                && p.p.sys_type != EMPTY_PARTITION
                && (is_extended(p.p.sys_type) != (pct == 1))) {
                warn("Extended partition not where expected\n");
                if (!force)
                        return 0;
        }

        z->partitions[pno] = p;
        if (pno >= z->partno)
                z->partno += 4;                 /* reqd for out_partition() */

        if (interactive)
                out_partition(dev, 0, &(z->partitions[pno]), z, B);

        return 1;
}

/* ep either points to the extended partition to contain this one,
   or to the empty partition that may become extended or is 0 */
static int
read_partition(char *dev, int interactive, int pno, struct part_desc *ep,
                           struct disk_desc *z)
{
        struct part_desc *p = &(z->partitions[pno]);
        int i;

        if (one_only) {
                *p = oldp.partitions[pno];
                if (one_only_pno != pno)
                        goto ret;
        } else if (!show_extended && pno > 4 && pno % 4)
                goto ret;

        while (!(i = read_line(pno, ep, dev, interactive, z)))
                if (!interactive)
                        fatalError("bad input\n");
        if (i < 0) {
                p->ep = ep;
                return 0;
        }

  ret:
        p->ep = ep;
        if (pno >= z->partno)
                z->partno += 4;
        return 1;
}

static void
read_partition_chain(char *dev, int interactive, struct part_desc *ep,
                                         struct disk_desc *z)
{
        int i, base;

        eob = 0;
        while (1) {
                base = z->partno;
                if (base + 4 > SIZE(z->partitions)) {
                        printf("too many partitions\n");
                        break;
                }
                for (i = 0; i < 4; i++)
                        if (!read_partition(dev, interactive, base + i, ep, z))
                                return;
                for (i = 0; i < 4; i++) {
                        ep = &(z->partitions[base + i]);
                        if (is_extended(ep->p.sys_type) && ep->size)
                                break;
                }
                if (i == 4) {
                        /* nothing found - maybe an empty partition is going
                           to be extended */
                        if (one_only || show_extended)
                                break;
                        ep = &(z->partitions[base + 1]);
                        if (ep->size || ep->p.sys_type != EMPTY_PARTITION)
                                break;
                }
        }
}

static void read_input(char *dev, int interactive, struct disk_desc *z)
{
        int i;
        struct part_desc *partitions = &(z->partitions[0]), *ep;

        for (i = 0; i < SIZE(z->partitions); i++)
                partitions[i] = zero_part_desc;
        z->partno = 0;

        if (interactive)
                warn
                        ("Input in the following format; absent fields get a default value.\n"
                         "<start> <size> <type [E,S,L,X,hex]> <bootable [-,*]> <c,h,s> <c,h,s>\n"
                         "Usually you only need to specify <start> and <size> (and perhaps <type>).\n");
        eof = 0;

        for (i = 0; i < 4; i++)
                read_partition(dev, interactive, i, 0, z);
        for (i = 0; i < 4; i++) {
                ep = partitions + i;
                if (is_extended(ep->p.sys_type) && ep->size)
                        read_partition_chain(dev, interactive, ep, z);
        }
        add_sector_and_offset(z);
}

/*
 *  G. The command line
 */

static void version(void)
{
        printf("%s %s %s (aeb@cwi.nl, %s)\n", PROGNAME, "version", VERSION,
                   DATE);
}

static char short_opts[] = "cdfgilnqsu:vx?1A::C:DH:I:LN:O:RS:TU::V";

#define PRINT_ID 0400
#define CHANGE_ID 01000

static const struct option long_opts[] = {
        {"change-id", no_argument, NULL, 'c' + CHANGE_ID},
        {"print-id", no_argument, NULL, 'c' + PRINT_ID},
        {"id", no_argument, NULL, 'c'},
        {"dump", no_argument, NULL, 'd'},
        {"force", no_argument, NULL, 'f'},
        {"show-geometry", no_argument, NULL, 'g'},
        {"increment", no_argument, NULL, 'i'},
        {"list", no_argument, NULL, 'l'},
        {"quiet", no_argument, NULL, 'q'},
        {"show-size", no_argument, NULL, 's'},
        {"unit", required_argument, NULL, 'u'},
        {"version", no_argument, NULL, 'v'},
        {"show-extended", no_argument, NULL, 'x'},
        {"help", no_argument, NULL, '?'},
        {"one-only", no_argument, NULL, '1'},
        {"cylinders", required_argument, NULL, 'C'},
        {"heads", required_argument, NULL, 'H'},
        {"sectors", required_argument, NULL, 'S'},
        {"activate", optional_argument, NULL, 'A'},
        {"DOS", no_argument, NULL, 'D'},
        {"Linux", no_argument, NULL, 'L'},
        {"re-read", no_argument, NULL, 'R'},
        {"list-types", no_argument, NULL, 'T'},
        {"unhide", optional_argument, NULL, 'U'},
        {"no-reread", no_argument, NULL, 160},
        {"IBM", no_argument, NULL, 161},
        {"leave-last", no_argument, NULL, 161},
/* undocumented flags - not all completely implemented */
        {"in-order", no_argument, NULL, 128},
        {"not-in-order", no_argument, NULL, 129},
        {"inside-outer", no_argument, NULL, 130},
        {"not-inside-outer", no_argument, NULL, 131},
        {"nested", no_argument, NULL, 132},
        {"chained", no_argument, NULL, 133},
        {"onesector", no_argument, NULL, 134},
        {NULL, 0, NULL, 0}
};

/* default devices to list */
static struct devd {
        char *pref, *letters;
} defdevs[] = {
        {
        "hd", "abcdefgh"}, {
        "sd", "abcde"}, {
        "xd", "ab"}, {
        "ed", "abcd"}
};

static int is_ide_cdrom(char *device)
{
        /* No device was given explicitly, and we are trying some
           likely things.  But opening /dev/hdc may produce errors like
           "hdc: tray open or drive not ready"
           if it happens to be a CD-ROM drive. So try to be careful.
           This only works since 2.1.73. */

        FILE *procf;
        char buf[100];
        struct stat statbuf;

        sprintf(buf, "/proc/ide/%s/media", device + 5);
        procf = fopen(buf, "r");
        if (procf != NULL && fgets(buf, sizeof(buf), procf))
                return !strncmp(buf, "cdrom", 5);

        /* Now when this proc file does not exist, skip the
           device when it is read-only. */
        if (stat(device, &statbuf) == 0)
                return (statbuf.st_mode & 0222) == 0;

        return 0;
}

static void do_list(char *dev, int silent);
static void do_size(char *dev, int silent);
static void do_geom(char *dev, int silent);
static void do_fdisk(char *dev);
static void do_reread(char *dev);
static void do_change_id(char *dev, char *part, char *id);
static void do_unhide(char **av, int ac, char *arg);
static void do_activate(char **av, int ac, char *arg);

static int total_size;

extern int sfdisk_main(int argc, char **argv)
{
        int c;
        char *dev;
        int opt_size = 0;
        int opt_out_geom = 0;
        int opt_reread = 0;
        int activate = 0;
        int do_id = 0;
        int unhide = 0;
        char *activatearg = 0;
        char *unhidearg = 0;

        if (argc < 1)
                usage(sfdisk_usage);

        while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL)) !=
                   -1) {
                switch (c) {
                case 'f':
                        force = 1;
                        break;                          /* does not imply quiet */
                case 'g':
                        opt_out_geom = 1;
                        break;
                case 'i':
                        increment = 1;
                        break;
                case 'c':
                case 'c' + PRINT_ID:
                case 'c' + CHANGE_ID:
                        do_id = c;
                        break;
                case 'd':
                        dump = 1;                       /* fall through */
                case 'l':
                        opt_list = 1;
                        break;
                case 'n':
                        no_write = 1;
                        break;
                case 'q':
                        quiet = 1;
                        break;
                case 's':
                        opt_size = 1;
                        break;
                case 'u':
                        set_format(*optarg);
                        break;
                case 'v':
                        version();
                        exit(0);
                case 'x':
                        show_extended = 1;
                        break;
                case 'A':
                        activatearg = optarg;
                        activate = 1;
                        break;
                case 'C':
                        U.cylinders = atoi(optarg);
                        break;
                case 'D':
                        DOS = 1;
                        break;
                case 'H':
                        U.heads = atoi(optarg);
                        break;
                case 'L':
                        Linux = 1;
                        break;
                case 'N':
                        one_only = atoi(optarg);
                        break;
                case 'I':
                        restore_sector_file = optarg;
                        break;
                case 'O':
                        save_sector_file = optarg;
                        break;
                case 'R':
                        opt_reread = 1;
                        break;
                case 'S':
                        U.sectors = atoi(optarg);
                        break;
                case 'T':
                        list_types();
                        exit(0);
                case 'U':
                        unhidearg = optarg;
                        unhide = 1;
                        break;
                case 'V':
                        verify = 1;
                        break;
                case '?':
                default:
                        usage(sfdisk_usage);

                        /* undocumented flags */
                case 128:
                        partitions_in_order = 1;
                        break;
                case 129:
                        partitions_in_order = 0;
                        break;
                case 130:
                        all_logicals_inside_outermost_extended = 1;
                        break;
                case 131:
                        all_logicals_inside_outermost_extended = 0;
                        break;
                case 132:
                        boxes = NESTED;
                        break;
                case 133:
                        boxes = CHAINED;
                        break;
                case 134:
                        boxes = ONESECTOR;
                        break;

                        /* more flags */
                case 160:
                        no_reread = 1;
                        break;
                case 161:
                        leave_last = 1;
                        break;
                }
        }

        if (optind == argc && (opt_list || opt_out_geom || opt_size || verify)) {
                struct devd *dp;
                char *lp;
                char device[10];

                total_size = 0;

                for (dp = defdevs; dp - defdevs < SIZE(defdevs); dp++) {
                        lp = dp->letters;
                        while (*lp) {
                                sprintf(device, "/dev/%s%c", dp->pref, *lp++);
                                if (!strcmp(dp->pref, "hd") && is_ide_cdrom(device))
                                        continue;
                                if (opt_out_geom)
                                        do_geom(device, 1);
                                if (opt_size)
                                        do_size(device, 1);
                                if (opt_list || verify)
                                        do_list(device, 1);
                        }
                }

                if (opt_size)
                        printf("total: %d blocks\n", total_size);

                exit(exit_status);
        }

        if (optind == argc)
                usage(sfdisk_usage);

        if (opt_list || opt_out_geom || opt_size || verify) {
                while (optind < argc) {
                        if (opt_out_geom)
                                do_geom(argv[optind], 0);
                        if (opt_size)
                                do_size(argv[optind], 0);
                        if (opt_list || verify)
                                do_list(argv[optind], 0);
                        optind++;
                }
                exit(exit_status);
        }

        if (activate) {
                do_activate(argv + optind, argc - optind, activatearg);
                exit(exit_status);
        }
        if (unhide) {
                do_unhide(argv + optind, argc - optind, unhidearg);
                exit(exit_status);
        }
        if (do_id) {
                if ((do_id & PRINT_ID) != 0 && optind != argc - 2)
                        fatalError("usage: sfdisk --print-id device partition-number\n");
                else if ((do_id & CHANGE_ID) != 0 && optind != argc - 3)
                        fatalError
                                ("usage: sfdisk --change-id device partition-number Id\n");
                else if (optind != argc - 3 && optind != argc - 2)
                        fatalError("usage: sfdisk --id device partition-number [Id]\n");
                do_change_id(argv[optind], argv[optind + 1],
                                         (optind == argc - 2) ? 0 : argv[optind + 2]);
                exit(exit_status);
        }

        if (optind != argc - 1)
                fatalError("can specify only one device (except with -l or -s)\n");
        dev = argv[optind];

        if (opt_reread)
                do_reread(dev);
        else if (restore_sector_file)
                restore_sectors(dev);
        else
                do_fdisk(dev);

        return (TRUE);
}

/*
 *  H. Listing the current situation
 */

static int my_open(char *dev, int rw, int silent)
{
        int fd, mode;

        mode = (rw ? O_RDWR : O_RDONLY);
        fd = open(dev, mode);
        if (fd < 0 && !silent) {
                perror(dev);
                fatalError("cannot open %s %s\n", dev,
                          rw ? "read-write" : "for reading");
        }
        return fd;
}

static void do_list(char *dev, int silent)
{
        int fd;
        struct disk_desc *z;

        fd = my_open(dev, 0, silent);
        if (fd < 0)
                return;

        z = &oldp;

        free_sectors();
        get_cylindersize(dev, fd, dump ? 1 : opt_list ? 0 : 1);
        get_partitions(dev, fd, z);

        if (opt_list)
                out_partitions(dev, z);

        if (verify) {
                if (partitions_ok(z))
                        warn("%s: OK\n", dev);
                else
                        exit_status = 1;
        }
}

static void do_geom(char *dev, int silent)
{
        int fd;
        struct hd_geometry g;

        fd = my_open(dev, 0, silent);
        if (fd < 0)
                return;

        /* get_cylindersize(dev, fd, silent); */
        if (!ioctl(fd, HDIO_GETGEO, &g))
                printf("%s: %d cylinders, %d heads, %d sectors/track\n",
                           dev, g.cylinders, g.heads, g.sectors);
        else
                printf("%s: unknown geometry\n", dev);
}

/* for compatibility with earlier fdisk: provide option -s */
static void do_size(char *dev, int silent)
{
        int fd;
        long size;

        fd = my_open(dev, 0, silent);
        if (fd < 0)
                return;

        if (ioctl(fd, BLKGETSIZE, &size)) {
                if (!silent) {
                        perror(dev);
                        fatalError("BLKGETSIZE ioctl failed for %s\n", dev);
                }
                return;
        }

        size /= 2;                                      /* convert sectors to blocks */

        /* a CDROM drive without mounted CD yields MAXINT */
        if (silent && size == ((1 << 30) - 1))
                return;

        if (silent)
                printf("%s: %9ld\n", dev, size);
        else
                printf("%ld\n", size);

        total_size += size;
}

/*
 * Activate: usually one wants to have a single primary partition
 * to be active. OS/2 fdisk makes non-bootable logical partitions
 * active - I don't know what that means to OS/2 Boot Manager.
 *
 * Call: activate /dev/hda 2 5 7        make these partitions active
 *                                      and the remaining ones inactive
 * Or:   sfdisk -A /dev/hda 2 5 7
 *
 * If only a single partition must be active, one may also use the form
 *       sfdisk -A2 /dev/hda
 *
 * With "activate /dev/hda" or "sfdisk -A /dev/hda" the active partitions
 * are listed but not changed. To get zero active partitions, use
 * "activate /dev/hda none" or "sfdisk -A /dev/hda none".
 * Use something like `echo ",,,*" | sfdisk -N2 /dev/hda' to only make
 * /dev/hda2 active, without changing other partitions.
 *
 * A warning will be given if after the change not precisely one primary
 * partition is active.
 *
 * The present syntax was chosen to be (somewhat) compatible with the
 * activate from the LILO package.
 */
static void set_active(struct disk_desc *z, char *pnam)
{
        int pno;

        pno = asc_to_index(pnam, z);
        z->partitions[pno].p.bootable = 0x80;
}

static void do_activate(char **av, int ac, char *arg)
{
        char *dev = av[0];
        int fd;
        int rw, i, pno, lpno;
        struct disk_desc *z;

        z = &oldp;

        rw = (!no_write && (arg || ac > 1));
        fd = my_open(dev, rw, 0);

        free_sectors();
        get_cylindersize(dev, fd, 1);
        get_partitions(dev, fd, z);

        if (!arg && ac == 1) {
                /* list active partitions */
                for (pno = 0; pno < z->partno; pno++) {
                        if (z->partitions[pno].p.bootable) {
                                lpno = index_to_linux(pno, z);
                                if (pno == linux_to_index(lpno, z))
                                        printf("%s%d\n", dev, lpno);
                                else
                                        printf("%s#%d\n", dev, pno);
                                if (z->partitions[pno].p.bootable != 0x80)
                                        warn("bad active byte: 0x%x instead of 0x80\n",
                                                 z->partitions[pno].p.bootable);
                        }
                }
        } else {
                /* clear `active byte' everywhere */
                for (pno = 0; pno < z->partno; pno++)
                        z->partitions[pno].p.bootable = 0;

                /* then set where desired */
                if (ac == 1)
                        set_active(z, arg);
                else
                        for (i = 1; i < ac; i++)
                                set_active(z, av[i]);

                /* then write to disk */
                if (write_partitions(dev, fd, z))
                        warn("Done\n\n");
                else
                        exit_status = 1;
        }
        i = 0;
        for (pno = 0; pno < z->partno && pno < 4; pno++)
                if (z->partitions[pno].p.bootable)
                        i++;
        if (i != 1)
                warn
                        ("You have %d active primary partitions. This does not matter for LILO,\n"
                         "but the DOS MBR will only boot a disk with 1 active partition.\n",
                         i);
}

static void set_unhidden(struct disk_desc *z, char *pnam)
{
        int pno;
        unsigned char id;

        pno = asc_to_index(pnam, z);
        id = z->partitions[pno].p.sys_type;
        if (id == 0x11 || id == 0x14 || id == 0x16 || id == 0x17)
                id -= 0x10;
        else
                fatalError("partition %s has id %x and is not hidden\n", pnam, id);
        z->partitions[pno].p.sys_type = id;
}

/*
 * maybe remove and make part of --change-id
 */
static void do_unhide(char **av, int ac, char *arg)
{
        char *dev = av[0];
        int fd, rw, i;
        struct disk_desc *z;

        z = &oldp;

        rw = !no_write;
        fd = my_open(dev, rw, 0);

        free_sectors();
        get_cylindersize(dev, fd, 1);
        get_partitions(dev, fd, z);

        /* unhide where desired */
        if (ac == 1)
                set_unhidden(z, arg);
        else
                for (i = 1; i < ac; i++)
                        set_unhidden(z, av[i]);

        /* then write to disk */
        if (write_partitions(dev, fd, z))
                warn("Done\n\n");
        else
                exit_status = 1;
}

static void do_change_id(char *dev, char *pnam, char *id)
{
        int fd, rw, pno;
        struct disk_desc *z;
        unsigned long i;

        z = &oldp;

        rw = !no_write;
        fd = my_open(dev, rw, 0);

        free_sectors();
        get_cylindersize(dev, fd, 1);
        get_partitions(dev, fd, z);

        pno = asc_to_index(pnam, z);
        if (id == 0) {
                printf("%x\n", z->partitions[pno].p.sys_type);
                return;
        }
        i = strtoul(id, NULL, 16);
        if (i > 255)
                fatalError("Bad Id %lx\n", i);
        z->partitions[pno].p.sys_type = i;

        if (write_partitions(dev, fd, z))
                warn("Done\n\n");
        else
                exit_status = 1;
}

static void do_reread(char *dev)
{
        int fd;

        fd = my_open(dev, 0, 0);
        if (reread_ioctl(fd))
                printf("This disk is currently in use.\n");
}

/*
 *  I. Writing the new situation
 */

static void do_fdisk(char *dev)
{
        int fd;
        int c, answer;
        struct stat statbuf;
        int interactive = isatty(0);
        struct disk_desc *z;

        if (stat(dev, &statbuf) < 0) {
                perror(dev);
                fatalError("Fatal error: cannot find %s\n", dev);
        }
        if (!S_ISBLK(statbuf.st_mode)) {
                warn("Warning: %s is not a block device\n", dev);
                no_reread = 1;
        }
        fd = my_open(dev, !no_write, 0);

        if (!no_write && !no_reread) {
                warn("Checking that no-one is using this disk right now ...\n");
                if (reread_ioctl(fd)) {
                        printf
                                ("\nThis disk is currently in use - repartitioning is probably a bad idea."
                                 "Umount all file systems, and swapoff all swap partitions on this disk."
                                 "Use the --no-reread flag to suppress this check.\n");
                        if (!force) {
                                printf("Use the --force flag to overrule all checks.\n");
                                exit(1);
                        }
                } else
                        warn("OK");
        }

        z = &oldp;

        free_sectors();
        get_cylindersize(dev, fd, 0);
        get_partitions(dev, fd, z);

        printf("Old situation:\n");
        out_partitions(dev, z);

        if (one_only && (one_only_pno = linux_to_index(one_only, z)) < 0)
                fatalError("Partition %d does not exist, cannot change it\n", one_only);

        z = &newp;

        while (1) {

                read_input(dev, interactive, z);

                printf("New situation:\n");
                out_partitions(dev, z);

                if (!partitions_ok(z) && !force) {
                        if (!interactive)
                                fatalError("I don't like these partitions - nothing changed.\n"
                                          "(If you really want this, use the --force option.)\n");
                        else
                                printf
                                        ("I don't like this - probably you should answer No\n");
                }
          ask:
                if (interactive) {
                        if (no_write)
                                printf("Are you satisfied with this? [ynq] ");
                        else
                                printf("Do you want to write this to disk? [ynq] ");
                        answer = c = getchar();
                        while (c != '\n' && c != EOF)
                                c = getchar();
                        if (c == EOF)
                                printf("\nsfdisk: premature end of input\n");
                        if (c == EOF || answer == 'q' || answer == 'Q') {
                                fatalError("Quitting - nothing changed\n");
                        } else if (answer == 'n' || answer == 'N') {
                                continue;
                        } else if (answer == 'y' || answer == 'Y') {
                                break;
                        } else {
                                printf("Please answer one of y,n,q\n");
                                goto ask;
                        }
                } else
                        break;
        }

        if (write_partitions(dev, fd, z))
                printf("Successfully wrote the new partition table\n\n");
        else
                exit_status = 1;

        reread_disk_partition(dev, fd);

        warn
                ("If you created or changed a DOS partition, /dev/foo7, say, then use dd(1)\n"
                 "to zero the first 512 bytes:  dd if=/dev/zero of=/dev/foo7 bs=512 count=1\n"
                 "(See fdisk(8).)\n");

        sync();                                         /* superstition */
        sleep(3);
        exit(exit_status);
}