Imported from util-linux-2.9i tarball.

1 files changed, 2642 insertions, 0 deletions

diff --git a/fdisk/cfdisk.c b/fdisk/cfdisk.c
new file mode 100644
index 000000000..96ddbbf24
--- /dev/null
+++ b/fdisk/cfdisk.c
@@ -0,0 +1,2642 @@
+/****************************************************************************
+ *
+ *     CFDISK
+ *
+ * cfdisk is a curses based disk drive partitioning program that can
+ * create partitions for a wide variety of operating systems including
+ * Linux, MS-DOS and OS/2.
+ *
+ * cfdisk was inspired by the fdisk program, by A. V. Le Blanc
+ * (LeBlanc@mcc.ac.uk).
+ *
+ *     Copyright (C) 1994 Kevin E. Martin (martin@cs.unc.edu)
+ *
+ * cfdisk 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * cfdisk is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with cfdisk; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Created:	Fri Jan 28 22:46:58 1994, martin@cs.unc.edu
+ * >2GB patches: Sat Feb 11 09:08:10 1995, faith@cs.unc.edu
+ * Prettier menus: Sat Feb 11 09:08:25 1995, Janne Kukonlehto
+ *                                           <jtklehto@stekt.oulu.fi>
+ * Versions 0.8e-n: aeb@cwi.nl
+ *  Recognition of NTFS / HPFS difference inspired by patches
+ *  from Marty Leisner <leisner@sdsp.mc.xerox.com>
+ *  Exit codes by Enrique Zanardi <ezanardi@ull.es>:
+ *     0: all went well
+ *     1: command line error
+ *     2: hardware problems [BAD_SEEK, BAD_READ, BAD_WRITE or BAD_OPEN].
+ *     3: ioctl(fd, HDIO_GETGEO,...) failed [BAD_GEOMETRY].
+ *     4: bad partition table on disk. [BAD_PRIMARY or BAD_LOGICAL].
+ *
+ ****************************************************************************/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <getopt.h>
+#include <fcntl.h>
+#ifdef SLCURSES
+  #include <slcurses.h>
+#else
+#if NCH
+  #include <ncurses.h>
+#else
+  #include <curses.h>
+#endif
+#endif
+#include <signal.h>
+#include <math.h>
+#include <locale.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <linux/types.h>
+#include <linux/hdreg.h>
+#include <linux/fs.h>		/* for BLKRRPART */
+
+#if defined(__GNUC__) || defined(HAS_LONG_LONG)
+typedef long long ext2_loff_t;
+#else
+typedef long      ext2_loff_t;
+#endif
+
+extern ext2_loff_t ext2_llseek(unsigned int fd, ext2_loff_t offset,
+			       unsigned int origin);
+
+#define VERSION "0.8n"
+
+#define DEFAULT_DEVICE "/dev/hda"
+#define ALTERNATE_DEVICE "/dev/sda"
+
+#define LINE_LENGTH 80
+#define MAXIMUM_PARTS 60
+
+#define SECTOR_SIZE 512
+
+#define MAX_CYLINDERS 65535
+#define MAX_HEADS 255
+#define MAX_SECTORS 63
+
+#define ACTIVE_FLAG 0x80
+#define PART_TABLE_FLAG0 0x55
+#define PART_TABLE_FLAG1 0xAA
+
+#define UNUSABLE -1
+#define FREE_SPACE     0x00
+#define DOS_EXTENDED   0x05
+#define OS2_OR_NTFS    0x07
+#define WIN98_EXTENDED 0x0f
+#define LINUX_EXTENDED 0x85
+#define LINUX_MINIX    0x81
+#define LINUX_SWAP     0x82
+#define LINUX          0x83
+
+#define ADD_EXISTS "This partition is already in use"
+#define ADD_UNUSABLE "This partition is unusable"
+#define DEL_EMPTY "Cannot delete an empty partition"
+#define ID_EMPTY "Cannot change FS Type to empty"
+#define ID_EXT "Cannot change FS Type to extended"
+#define NEED_EXT "No room to create the extended partition"
+#define NO_FLAGS "Cannot make this partition bootable"
+#define NO_MORE_PARTS "No more partitions"
+#define PRINT_OPEN_ERR "Cannot open file '%s'"
+#define TWO_EXTENDEDS "Cannot create logical drive here -- would create two extended partitions"
+#define TYPE_EMPTY "Cannot change the type of an empty partition"
+#define BAD_COMMAND "Illegal command"
+#define MAX_UNMAXABLE "Cannot maximize this partition"
+#define BAD_OPEN "Cannot open disk drive"
+#define BAD_SEEK "Cannot seek on disk drive"
+#define BAD_READ "Cannot read disk drive"
+#define BAD_WRITE "Cannot write disk drive"
+#define BAD_GEOMETRY "Cannot read disk drive geometry"
+#define BAD_PRIMARY "Bad primary partition"
+#define BAD_LOGICAL "Bad logical partition"
+#define BAD_CYLINDERS "Illegal cylinders value"
+#define BAD_HEADS "Illegal heads value"
+#define BAD_SECTORS "Illegal sectors value"
+#define READONLY_WARN "Opened disk read-only - you have no permission to write"
+#define WRITE_WARN "Warning!!  This may destroy data on your disk!"
+#define YES_NO "Please enter `yes' or `no'"
+#define WRITING_PART "Writing partition table to disk..."
+#define YES_WRITE "Wrote partition table to disk"
+#define NO_WRITE "Did not write partition table to disk"
+#define RRPART_FAILED "Wrote partition table, but re-read table failed.  Reboot to update table."
+#define NOT_DOS_MBR_BOOTABLE "Not precisely one primary partition is bootable. DOS MBR cannot boot this."
+
+#define PRI_OR_LOG -1
+#define PRIMARY -2
+#define LOGICAL -3
+
+#define COL_ID_WIDTH 20
+
+#define CR '\015'
+#define ESC '\033'
+#define DEL '\177'
+#define BELL '\007'
+/* '\014' == ^L */
+#define REDRAWKEY '\014'
+
+/* Display units */
+#define MEGABYTES 1
+#define SECTORS 2
+#define CYLINDERS 3
+
+#define GS_DEFAULT -1
+#define GS_ESCAPE -2
+
+#define PRINT_RAW_TABLE 1
+#define PRINT_SECTOR_TABLE 2
+#define PRINT_PARTITION_TABLE 4
+
+#define IS_PRIMARY(p) ((p) >= 0 && (p) < 4)
+#define IS_LOGICAL(p) ((p) > 3)
+
+#define round_int(d) ((double)((int)(d+0.5)))
+#define ceiling(d) ((double)(((d) != (int)(d)) ? (int)(d+1.0) : (int)(d)))
+
+#define set_hsc(h,s,c,sector) \
+{ \
+      s = sector % sectors + 1;	\
+      sector /= sectors;	\
+      h = sector % heads;	\
+      sector /= heads;		\
+      c = sector & 0xFF;	\
+      s |= (sector >> 2) & 0xC0;\
+}
+
+#define is_extended(x)	((x) == DOS_EXTENDED || (x) == WIN98_EXTENDED || \
+			 (x) == LINUX_EXTENDED)
+
+#define is_dos_partition(x) ((x) == 1 || (x) == 4 || (x) == 6)
+#define may_have_dos_label(x) (is_dos_partition(x) \
+   || (x) == 7 || (x) == 0xb || (x) == 0xc || (x) == 0xe \
+   || (x) == 0x11 || (x) == 0x14 || (x) == 0x16 || (x) == 0x17)
+
+struct partition {
+        unsigned char boot_ind;         /* 0x80 - active */
+        unsigned char head;             /* starting head */
+        unsigned char sector;           /* starting sector */
+        unsigned char cyl;              /* starting cylinder */
+        unsigned char sys_ind;          /* What partition type */
+        unsigned char end_head;         /* end head */
+        unsigned char end_sector;       /* end sector */
+        unsigned char end_cyl;          /* end cylinder */
+        unsigned char start4[4];        /* starting sector counting from 0 */
+        unsigned char size4[4];         /* nr of sectors in partition */
+};
+
+/* start_sect and nr_sects are stored little endian on all machines */
+/* moreover, they are not aligned correctly */
+void
+store4_little_endian(unsigned char *cp, unsigned int val) {
+	cp[0] = (val & 0xff);
+	cp[1] = ((val >> 8) & 0xff);
+	cp[2] = ((val >> 16) & 0xff);
+	cp[3] = ((val >> 24) & 0xff);
+}
+
+unsigned int
+read4_little_endian(unsigned char *cp) {
+	return (uint)(cp[0]) + ((uint)(cp[1]) << 8)
+		+ ((uint)(cp[2]) << 16) + ((uint)(cp[3]) << 24);
+}
+
+void
+set_start_sect(struct partition *p, unsigned int start_sect) {
+	store4_little_endian(p->start4, start_sect);
+}
+
+unsigned int
+get_start_sect(struct partition *p) {
+	return read4_little_endian(p->start4);
+}
+
+void
+set_nr_sects(struct partition *p, unsigned int nr_sects) {
+	store4_little_endian(p->size4, nr_sects);
+}
+
+unsigned int
+get_nr_sects(struct partition *p) {
+	return read4_little_endian(p->size4);
+}
+
+#define ALIGNMENT 2
+typedef union {
+    struct {
+	unsigned char align[ALIGNMENT];
+	unsigned char b[SECTOR_SIZE];
+    } c;
+    struct {
+	unsigned char align[ALIGNMENT];
+	unsigned char buffer[0x1BE];
+	struct partition part[4];
+	unsigned char magicflag[2];
+    } p;
+} partition_table;
+
+typedef struct {
+    int first_sector;	/* first sector in partition */
+    int last_sector;	/* last sector in partition */
+    int offset;		/* offset from first sector to start of data */
+    int flags;		/* active == 0x80 */
+    int id;		/* filesystem type */
+    int num;		/* number of partition -- primary vs. logical */
+#define LABELSZ 16
+    char volume_label[LABELSZ+1];
+#define OSTYPESZ 8
+    char ostype[OSTYPESZ+1];
+#define FSTYPESZ 8
+    char fstype[FSTYPESZ+1];
+} partition_info;
+
+char *disk_device = DEFAULT_DEVICE;
+int fd;
+int heads = 0;
+int sectors = 0;
+int cylinders = 0;
+int changed = FALSE;
+int opened = FALSE;
+int opentype;
+int curses_started = 0;
+
+partition_info p_info[MAXIMUM_PARTS];
+partition_info ext_info;
+int num_parts = 0;
+
+int logical = 0;
+int logical_sectors[MAXIMUM_PARTS];
+
+__sighandler_t old_SIGINT, old_SIGTERM;
+
+int arrow_cursor = FALSE;
+int display_units = MEGABYTES;
+int zero_table = FALSE;
+int print_only = 0;
+
+/* Curses screen information */
+int cur_part = 0;
+int warning_last_time = FALSE;
+int defined = FALSE;
+int COLUMNS = 80;
+int NUM_ON_SCREEN = 1;
+
+/* Y coordinates */
+int HEADER_START = 0;
+int DISK_TABLE_START = 5;
+int WARNING_START = 23;
+int COMMAND_LINE_Y = 21;
+
+/* X coordinates */
+int NAME_START = 4;
+int FLAGS_START = 16;
+int PTYPE_START = 28;
+int FSTYPE_START = 38;
+int LABEL_START = 54;
+int SIZE_START = 70;
+int COMMAND_LINE_X = 5;
+
+#define NUM_PART_TYPES 256
+char *partition_type[NUM_PART_TYPES] = {
+    [LINUX_MINIX] = "Linux/MINIX",
+    [LINUX_SWAP]  = "Linux Swap",
+    [LINUX]       = "Linux",
+    [FREE_SPACE]  = "Free Space",
+    [DOS_EXTENDED]= "Extended",
+    [LINUX_EXTENDED] = "Linux extended",
+    [0x01]        = "DOS FAT12",
+    [0x02]        = "XENIX root",
+    [0x03]        = "XENIX usr",
+    [0x04]        = "DOS FAT16",
+    [0x06]        = "DOS FAT16 (big)",
+    [OS2_OR_NTFS] = "OS/2 HPFS or NTFS",
+    [0x08]        = "AIX",
+    [0x09]        = "AIX bootable",
+    [0x0A]        = "OS/2 Boot Manager",
+    [0x0B]        = "Win95 FAT32",
+    [0x0C]        = "Win95 FAT32 (LBA)",
+    [0x0E]        = "Win95 FAT16 (LBA)",
+    [0x0F]        = "Win95 Extended (LBA)",
+    [0x11]        = "Hidden DOS FAT12",
+    [0x14]        = "Hidden DOS FAT16",
+    [0x16]        = "Hidden DOS FAT16 (big)",
+    [0x17]        = "Hidden OS/2 HPFS or NTFS",
+    [0x40]        = "Venix 80286",
+    [0x41]	  = "PPC PReP boot",
+    [0x51]        = "Novell?",
+    [0x52]        = "Microport",
+    [0x63]        = "GNU HURD",
+    [0x64]        = "Novell Netware 286",
+    [0x65]        = "Novell Netware 386",
+    [0x75]        = "PC/IX",
+    [0x80]        = "Old MINIX",
+    [0x93]        = "Amoeba",
+    [0x94]        = "Amoeba BBT",
+    [0xA5]        = "BSD/386",
+    [0xA6]        = "OpenBSD",
+    [0xA7]        = "NEXTSTEP",
+    [0xB7]        = "BSDI fs",
+    [0xB8]        = "BSDI swap",
+    [0xC7]        = "Syrinx",
+    [0xDB]        = "CP/M",
+    [0xE1]        = "DOS access",
+    [0xE3]        = "DOS R/O",
+    [0xEB]	  = "BeOS fs",
+    [0xF2]        = "DOS secondary",
+    [0xFF]        = "BBT"
+};
+
+/* Some libc's have their own basename() */
+char *my_basename(char *devname)
+{
+    char *s = rindex(devname, '/');
+    return s ? s+1 : devname;
+}
+
+char *partition_type_text(int i)
+{
+    if (p_info[i].id == UNUSABLE)
+	 return "Unusable";
+    else if (p_info[i].id == FREE_SPACE)
+	 return "Free Space";
+    else if (p_info[i].id == LINUX) {
+	 if (!strcmp(p_info[i].fstype, "ext2"))
+	      return "Linux ext2";
+	 else
+	      return "Linux";
+    } else if (p_info[i].id == OS2_OR_NTFS) {
+	 if (!strncmp(p_info[i].fstype, "HPFS", 4))
+	      return "OS/2 HPFS";
+	 else if (!strncmp(p_info[i].ostype, "OS2", 3))
+	      return "OS/2 IFS";
+	 else if (!p_info[i].ostype)
+	      return p_info[i].ostype;
+	 else
+	      return "NTFS";
+    } else
+	 return partition_type[p_info[i].id];
+}
+
+void fdexit(int ret)
+{
+    if (opened)
+	close(fd);
+
+    if (changed) {
+	fprintf(stderr, "Disk has been changed.\n");
+	fprintf(stderr, "Reboot the system to ensure the partition "
+			"table is correctly updated.\n");
+	
+	fprintf( stderr, "\nWARNING: If you have created or modified any\n"
+		         "DOS 6.x partitions, please see the cfdisk manual\n"
+		         "page for additional information.\n" );
+    }
+
+    exit(ret);
+}
+
+int get_string(char *str, int len, char *def)
+{
+    char c;
+    int i = 0;
+    int x, y;
+    int use_def = FALSE;
+
+    getyx(stdscr, y, x);
+    clrtoeol();
+
+    str[i] = 0;
+
+    if (def != NULL) {
+	mvaddstr(y, x, def);
+	move(y, x);
+	use_def = TRUE;
+    }
+
+    refresh();
+    while ((c = getch()) != '\n' && c != CR) {
+	switch (c) {
+	case ESC:
+	    move(y, x);
+	    clrtoeol();
+	    refresh();
+	    return GS_ESCAPE;
+	case DEL:
+	case '\b':
+	    if (i > 0) {
+		str[--i] = 0;
+		mvaddch(y, x+i, ' ');
+		move(y, x+i);
+	    } else if (use_def) {
+		clrtoeol();
+		use_def = FALSE;
+	    } else
+		putchar(BELL);
+	    break;
+	default:
+	    if (i < len && isprint(c)) {
+		mvaddch(y, x+i, c);
+		if (use_def) {
+		    clrtoeol();
+		    use_def = FALSE;
+		}
+		str[i++] = c;
+		str[i] = 0;
+	    } else
+		putchar(BELL);
+	}
+	refresh();
+    }
+
+    if (use_def)
+	return GS_DEFAULT;
+    else
+	return i;
+}
+
+void clear_warning(void)
+{
+    int i;
+
+    if (!curses_started || !warning_last_time)
+	return;
+
+    move(WARNING_START,0);
+    for (i = 0; i < COLS; i++)
+	addch(' ');
+
+    warning_last_time = FALSE;
+}
+
+void print_warning(char *s)
+{
+    if (!curses_started) {
+	 fprintf(stderr, "%s\n", s);
+    } else {
+	mvaddstr(WARNING_START, (COLS-strlen(s))/2, s);
+	putchar(BELL); /* CTRL-G */
+
+	warning_last_time = TRUE;
+    }
+}
+
+void die_x(int ret);
+
+void fatal(char *s, int ret)
+{
+    char str[LINE_LENGTH];
+
+    if (curses_started) {
+	 sprintf(str, "FATAL ERROR: %s", s);
+	 mvaddstr(WARNING_START, (COLS-strlen(str))/2, str);
+	 sprintf(str, "Press any key to exit fdisk");
+	 mvaddstr(WARNING_START+1, (COLS-strlen(str))/2, str);
+	 putchar(BELL); /* CTRL-G */
+	 refresh();
+	 (void)getch();
+	 die_x(ret);
+    } else {
+	 fprintf(stderr, "FATAL ERROR: %s\n", s);
+	 exit(ret);
+    }
+}
+
+void die(int dummy)
+{
+    die_x(0);
+}
+
+void die_x(int ret)
+{
+    signal(SIGINT, old_SIGINT);
+    signal(SIGTERM, old_SIGTERM);
+#ifdef SLCURSES
+    SLsmg_gotorc(LINES-1, 0);
+    SLsmg_refresh();
+#else
+    mvcur(0, COLS-1, LINES-1, 0);
+#endif
+    nl();
+    endwin();
+    printf("\n");
+    fdexit(ret);
+}
+
+void read_sector(char *buffer, int sect_num)
+{
+    if (ext2_llseek(fd, ((ext2_loff_t) sect_num)*SECTOR_SIZE, SEEK_SET) < 0)
+	fatal(BAD_SEEK, 2);
+    if (read(fd, buffer, SECTOR_SIZE) != SECTOR_SIZE)
+	fatal(BAD_READ, 2);
+}
+
+void write_sector(char *buffer, int sect_num)
+{
+    if (ext2_llseek(fd, ((ext2_loff_t) sect_num)*SECTOR_SIZE, SEEK_SET) < 0)
+	fatal(BAD_SEEK, 2);
+    if (write(fd, buffer, SECTOR_SIZE) != SECTOR_SIZE)
+	fatal(BAD_WRITE, 2);
+}
+
+void dos_copy_to_info(char *to, int tosz, char *from, int fromsz) {
+     int i;
+
+     for(i=0; i<tosz && i<fromsz && isascii(from[i]); i++)
+	  to[i] = from[i];
+     to[i] = 0;
+}
+
+void get_dos_label(int i)
+{
+    char sector[128];
+#define DOS_OSTYPE_OFFSET 3
+#define DOS_LABEL_OFFSET 43
+#define DOS_FSTYPE_OFFSET 54
+#define DOS_OSTYPE_SZ 8
+#define DOS_LABEL_SZ 11
+#define DOS_FSTYPE_SZ 8
+    ext2_loff_t offset;
+
+    offset = ((ext2_loff_t) p_info[i].first_sector + p_info[i].offset)
+	 * SECTOR_SIZE;
+    if (ext2_llseek(fd, offset, SEEK_SET) == offset
+	&& read(fd, &sector, sizeof(sector)) == sizeof(sector)) {
+	 dos_copy_to_info(p_info[i].ostype, OSTYPESZ,
+			  sector+DOS_OSTYPE_OFFSET, DOS_OSTYPE_SZ);
+	 dos_copy_to_info(p_info[i].volume_label, LABELSZ,
+			  sector+DOS_LABEL_OFFSET, DOS_LABEL_SZ);
+	 dos_copy_to_info(p_info[i].fstype, FSTYPESZ,
+			  sector+DOS_FSTYPE_OFFSET, DOS_FSTYPE_SZ);
+    }
+}
+
+void get_ext2_label(int i)
+{
+#define EXT2_SUPER_MAGIC 0xEF53
+#define EXT2LABELSZ 16
+    struct ext2_super_block {
+	char  s_dummy0[56];
+	unsigned char  s_magic[2];
+	char  s_dummy1[62];
+	char  s_volume_name[EXT2LABELSZ];
+	char  s_last_mounted[64];
+	char  s_dummy2[824];
+    } sb;
+    char *label = sb.s_volume_name;
+    ext2_loff_t offset;
+    int j;
+
+    offset = ((ext2_loff_t) p_info[i].first_sector + p_info[i].offset)
+	 * SECTOR_SIZE + 1024;
+    if (ext2_llseek(fd, offset, SEEK_SET) == offset
+	&& read(fd, &sb, sizeof(sb)) == sizeof(sb)
+	&& sb.s_magic[0] + 256*sb.s_magic[1] == EXT2_SUPER_MAGIC) {
+	 for(j=0; j<EXT2LABELSZ; j++)
+	      if(!isprint(label[j]))
+		   label[j] = 0;
+	 label[EXT2LABELSZ] = 0;
+	 strncpy(p_info[i].volume_label, label, LABELSZ);
+	 strncpy(p_info[i].fstype, "ext2", FSTYPESZ);
+    }
+}
+
+void check_part_info(void)
+{
+    int i, pri = 0, log = 0;
+
+    for (i = 0; i < num_parts; i++)
+	if (p_info[i].id > 0 && IS_PRIMARY(p_info[i].num))
+	    pri++;
+	else if (p_info[i].id > 0 && IS_LOGICAL(p_info[i].num))
+	    log++;
+    if (is_extended(ext_info.id)) {
+	if (log > 0)
+	    pri++;
+	else {
+	    ext_info.first_sector = 0;
+	    ext_info.last_sector = 0;
+	    ext_info.offset = 0;
+	    ext_info.flags = 0;
+	    ext_info.id = FREE_SPACE;
+	    ext_info.num = PRIMARY;
+	}
+    }
+
+    if (pri >= 4) {
+	for (i = 0; i < num_parts; i++)
+	    if (p_info[i].id == FREE_SPACE || p_info[i].id == UNUSABLE) {
+		if (is_extended(ext_info.id)) {
+		    if (p_info[i].first_sector >= ext_info.first_sector &&
+			p_info[i].last_sector <= ext_info.last_sector) {
+			p_info[i].id = FREE_SPACE;
+			p_info[i].num = LOGICAL;
+		    } else if (i > 0 &&
+			       p_info[i-1].first_sector >=
+			       ext_info.first_sector &&
+			       p_info[i-1].last_sector <=
+			       ext_info.last_sector) {
+			p_info[i].id = FREE_SPACE;
+			p_info[i].num = LOGICAL;
+		    } else if (i < num_parts-1 &&
+			       p_info[i+1].first_sector >=
+			       ext_info.first_sector &&
+			       p_info[i+1].last_sector <=
+			       ext_info.last_sector) {
+			p_info[i].id = FREE_SPACE;
+			p_info[i].num = LOGICAL;
+		    } else
+			p_info[i].id = UNUSABLE;
+		} else /* if (!is_extended(ext_info.id)) */
+		    p_info[i].id = UNUSABLE;
+	    } else /* if (p_info[i].id > 0) */
+		while (0); /* Leave these alone */
+    } else { /* if (pri < 4) */
+	for (i = 0; i < num_parts; i++) {
+	    if (p_info[i].id == UNUSABLE)
+		p_info[i].id = FREE_SPACE;
+	    if (p_info[i].id == FREE_SPACE) {
+		if (is_extended(ext_info.id)) {
+		    if (p_info[i].first_sector >= ext_info.first_sector &&
+			p_info[i].last_sector <= ext_info.last_sector)
+			p_info[i].num = LOGICAL;
+		    else if (i > 0 &&
+			     p_info[i-1].first_sector >=
+			     ext_info.first_sector &&
+			     p_info[i-1].last_sector <=
+			     ext_info.last_sector)
+			p_info[i].num = PRI_OR_LOG;
+		    else if (i < num_parts-1 &&
+			     p_info[i+1].first_sector >=
+			     ext_info.first_sector &&
+			     p_info[i+1].last_sector <=
+			     ext_info.last_sector)
+			p_info[i].num = PRI_OR_LOG;
+		    else
+			p_info[i].num = PRIMARY;
+		} else /* if (!is_extended(ext_info.id)) */
+		    p_info[i].num = PRI_OR_LOG;
+	    } else /* if (p_info[i].id > 0) */
+		while (0); /* Leave these alone */
+	}
+    }
+}
+
+void remove_part(int i)
+{
+    int p;
+
+    for (p = i; p < num_parts; p++)
+	p_info[p] = p_info[p+1];
+
+    num_parts--;
+}
+
+void insert_empty_part(int i, int first, int last)
+{
+    int p;
+
+    for (p = num_parts; p > i; p--)
+	 p_info[p] = p_info[p-1];
+
+    p_info[i].first_sector = first;
+    p_info[i].last_sector = last;
+    p_info[i].offset = 0;
+    p_info[i].flags = 0;
+    p_info[i].id = FREE_SPACE;
+    p_info[i].num = PRI_OR_LOG;
+    p_info[i].volume_label[0] = 0;
+    p_info[i].fstype[0] = 0;
+    p_info[i].ostype[0] = 0;
+
+    num_parts++;
+}
+
+void del_part(int i)
+{
+    int num = p_info[i].num;
+
+    if (i > 0 && (p_info[i-1].id == FREE_SPACE ||
+		  p_info[i-1].id == UNUSABLE)) {
+	/* Merge with previous partition */
+	p_info[i-1].last_sector = p_info[i].last_sector;
+	remove_part(i--);
+    }
+
+    if (i < num_parts - 1 && (p_info[i+1].id == FREE_SPACE ||
+			      p_info[i+1].id == UNUSABLE)) {
+	/* Merge with next partition */
+	p_info[i+1].first_sector = p_info[i].first_sector;
+	remove_part(i);
+    }
+
+    if (i > 0)
+	p_info[i].first_sector = p_info[i-1].last_sector + 1;
+    else
+	p_info[i].first_sector = 0;
+
+    if (i < num_parts - 1)
+	p_info[i].last_sector = p_info[i+1].first_sector - 1;
+    else
+	p_info[i].last_sector = sectors*heads*cylinders - 1;
+
+    p_info[i].offset = 0;
+    p_info[i].flags = 0;
+    p_info[i].id = FREE_SPACE;
+    p_info[i].num = PRI_OR_LOG;
+
+    if (IS_LOGICAL(num)) {
+	/* We have a logical partition --> shrink the extended partition
+	 * if (1) this is the first logical drive, or (2) this is the
+	 * last logical drive; and if there are any other logical drives
+	 * then renumber the ones after "num".
+	 */
+	if (i == 0 || (i > 0 && IS_PRIMARY(p_info[i-1].num))) {
+	    ext_info.first_sector = p_info[i].last_sector + 1;
+	    ext_info.offset = 0;
+	}
+	if (i == num_parts-1 ||
+	    (i < num_parts-1 && IS_PRIMARY(p_info[i+1].num)))
+	    ext_info.last_sector = p_info[i].first_sector - 1;
+	for (i = 0; i < num_parts; i++)
+	    if (p_info[i].num > num)
+		p_info[i].num--;
+    }
+
+    /* Clean up the rest of the partitions */
+    check_part_info();
+}
+
+int add_part(int num, int id, int flags, int first, int last, int offset,
+	     int want_label)
+{
+    int i, pri = 0, log = 0;
+
+    if (num_parts == MAXIMUM_PARTS ||
+	first < 0 ||
+	first >= cylinders*heads*sectors ||
+	last < 0 ||
+	last >= cylinders*heads*sectors) {
+	return -1;		/* bad start or end */
+    }
+
+    for (i = 0; i < num_parts; i++)
+	if (p_info[i].id > 0 && IS_PRIMARY(p_info[i].num))
+	    pri++;
+	else if (p_info[i].id > 0 && IS_LOGICAL(p_info[i].num))
+	    log++;
+    if (is_extended(ext_info.id) && log > 0)
+	pri++;
+
+    if (IS_PRIMARY(num)) {
+	if (pri >= 4) {
+	    return -1;		/* no room for more */
+	} else
+	    pri++;
+    }
+
+    for (i = 0; i < num_parts && p_info[i].last_sector < first; i++);
+
+    if (i == num_parts || p_info[i].id != FREE_SPACE
+	|| last > p_info[i].last_sector) {
+	return -1;
+    }
+
+    if (is_extended(id)) {
+	if (ext_info.id != FREE_SPACE) {
+	    return -1;		/* second extended */
+	}
+	else if (IS_PRIMARY(num)) {
+	    ext_info.first_sector = first;
+	    ext_info.last_sector = last;
+	    ext_info.offset = offset;
+	    ext_info.flags = flags;
+	    ext_info.id = id;
+	    ext_info.num = num;
+	    ext_info.volume_label[0] = 0;
+	    ext_info.fstype[0] = 0;
+	    ext_info.ostype[0] = 0;
+	    return 0;
+	} else {
+	    return -1;		/* explicit extended logical */
+	}
+    }
+
+    if (IS_LOGICAL(num)) {
+	if (!is_extended(ext_info.id)) {
+	    print_warning("!!!! Internal error creating logical "
+			  "drive with no extended partition !!!!");
+	} else {
+	    /* We might have a logical partition outside of the extended
+	     * partition's range --> we have to extend the extended
+	     * partition's range to encompass this new partition, but we
+	     * must make sure that there are no primary partitions between
+	     * it and the closest logical drive in extended partition.
+	     */
+	    if (first < ext_info.first_sector) {
+		if (i < num_parts-1 && IS_PRIMARY(p_info[i+1].num)) {
+		    print_warning(TWO_EXTENDEDS);
+		    return -1;
+		} else {
+		    if (first == 0) {
+			ext_info.first_sector = 0;
+			ext_info.offset = first = offset;
+		    } else {
+			ext_info.first_sector = first;
+		    }
+		}
+	    } else if (last > ext_info.last_sector) {
+		if (i > 0 && IS_PRIMARY(p_info[i-1].num)) {
+		    print_warning(TWO_EXTENDEDS);
+		    return -1;
+		} else {
+		    ext_info.last_sector = last;
+		}
+	    }
+	}
+    }
+
+    if (first != p_info[i].first_sector &&
+	!(IS_LOGICAL(num) && first == offset)) {
+	insert_empty_part(i, p_info[i].first_sector, first-1);
+	i++;
+    }
+
+    if (last != p_info[i].last_sector)
+	insert_empty_part(i+1, last+1, p_info[i].last_sector);
+
+    p_info[i].first_sector = first;
+    p_info[i].last_sector = last;
+    p_info[i].offset = offset;
+    p_info[i].flags = flags;
+    p_info[i].id = id;
+    p_info[i].num = num;
+    p_info[i].volume_label[0] = 0;
+    p_info[i].fstype[0] = 0;
+    p_info[i].ostype[0] = 0;
+    if (want_label) {
+	 if (may_have_dos_label(id))
+	      get_dos_label(i);
+	 else if (id == LINUX)
+	      get_ext2_label(i);
+    }
+
+    check_part_info();
+
+    return 0;
+}
+
+int find_primary(void)
+{
+    int num = 0, cur = 0;
+
+    while (cur < num_parts && IS_PRIMARY(num))
+	if ((p_info[cur].id > 0 && p_info[cur].num == num) ||
+	    (is_extended(ext_info.id) && ext_info.num == num)) {
+	    num++;
+	    cur = 0;
+	} else
+	    cur++;
+
+    if (!IS_PRIMARY(num))
+	return -1;
+    else
+	return num;
+}
+
+int find_logical(int i)
+{
+    int num = -1;
+    int j;
+
+    for (j = i; j < num_parts && num == -1; j++)
+	if (p_info[j].id > 0 && IS_LOGICAL(p_info[j].num))
+	    num = p_info[j].num;
+
+    if (num == -1) {
+	num = 4;
+	for (j = 0; j < num_parts; j++)
+	    if (p_info[j].id > 0 && p_info[j].num == num)
+		num++;
+    }
+
+    return num;
+}
+
+void inc_logical(int i)
+{
+    int j;
+
+    for (j = i; j < num_parts; j++)
+	if (p_info[j].id > 0 && IS_LOGICAL(p_info[j].num))
+	    p_info[j].num++;
+}
+
+/* Command menu support by Janne Kukonlehto <jtklehto@phoenix.oulu.fi> September 1994 */
+
+/* Constants for menuType parameter of menuSelect function */
+#define MENU_HORIZ 1
+#define MENU_VERT 2
+#define MENU_ACCEPT_OTHERS 4
+#define MENU_BUTTON 8
+/* Miscellenous constants */
+#define MENU_SPACING 2
+#define MENU_MAX_ITEMS 256 /* for simpleMenu function */
+#define MENU_UP 1
+#define MENU_DOWN 2
+#define MENU_RIGHT 3
+#define MENU_LEFT 4
+
+struct MenuItem
+{
+    int key; /* Keyboard shortcut; if zero, then there is no more items in the menu item table */
+    char *name; /* Item name, should be eight characters with current implementation */
+    char *desc; /* Item description to be printed when item is selected */
+};
+
+/*
+ * Actual function which prints the button bar and highlights the active button
+ * Should not be called directly. Call function menuSelect instead.
+ */
+
+int menuUpdate( int y, int x, struct MenuItem *menuItems, int itemLength,
+		char *available, int menuType, int current )
+{
+    int i, lmargin = x, ymargin = y;
+    /* Print available buttons */
+    move( y, x ); clrtoeol();
+    for( i = 0; menuItems[i].key; i++ )
+    {
+        char buff[20];
+        int lenName;
+        /* Search next available button */
+        while( menuItems[i].key && !strchr(available, menuItems[i].key) )
+        {
+            i++;
+        }
+        if( !menuItems[i].key ) break; /* No more menu items */
+        /* If selected item is not available and we have bypassed it,
+	   make current item selected */
+        if( current < i && menuItems[current].key < 0 ) current = i;
+        /* If current item is selected, highlight it */
+        if( current == i ) /*attron( A_REVERSE )*/ standout ();
+        /* Print item */
+        lenName = strlen( menuItems[i].name );
+        if(lenName > itemLength)
+            print_warning("Menu item too long. Menu may look odd.");
+        if( menuType & MENU_BUTTON )
+            sprintf( buff, "[%*s%-*s]", (itemLength - lenName) / 2, "",
+                (itemLength - lenName + 1) / 2 + lenName, menuItems[i].name );
+        else
+            sprintf( buff, "%*s%-*s", (itemLength - lenName) / 2, "",
+                (itemLength - lenName + 1) / 2 + lenName, menuItems[i].name );
+        mvaddstr( y, x, buff );
+        /* Lowlight after selected item */
+        if( current == i ) /*attroff( A_REVERSE )*/ standend ();
+        /* Calculate position for the next item */
+        if( menuType & MENU_VERT )
+        {
+            y += 1;
+            if( y >= WARNING_START )
+            {
+                y = ymargin;
+                x += itemLength + MENU_SPACING;
+                if( menuType & MENU_BUTTON ) x += 2;
+            }
+        }
+        else
+        {
+            x += itemLength + MENU_SPACING;
+            if( menuType & MENU_BUTTON ) x += 2;
+            if( x > COLUMNS - lmargin - 12 )
+            {
+                x = lmargin;
+                y ++ ;
+            }
+        }
+    }
+    /* Print the description of selected item */
+    mvaddstr( WARNING_START + 1,
+	      (COLUMNS - strlen( menuItems[current].desc )) / 2,
+	      menuItems[current].desc );
+    return y;
+}
+
+/* This function takes a list of menu items, lets the user choose one of them *
+ * and returns the value keyboard shortcut of the selected menu item          */
+
+int menuSelect( int y, int x, struct MenuItem *menuItems, int itemLength, char *available, int menuType, int menuDefault )
+{
+    int i, ylast = y, key = 0, current = menuDefault;
+    if( !( menuType & ( MENU_HORIZ | MENU_VERT ) ) )	
+    {
+        print_warning("Menu without direction. Defaulting horizontal.");
+        menuType |= MENU_HORIZ;
+    }
+    /* Make sure that the current is one of the available items */
+    while( !strchr(available, menuItems[current].key) )
+    {
+        current ++ ;
+        if( !menuItems[current].key ) current = 0;
+    }
+    /* Repeat until allowable choice has been made */
+    while( !key )
+    {
+        /* Display the menu */
+        ylast = menuUpdate( y, x, menuItems, itemLength, available,
+			    menuType, current );
+        refresh();
+        key = getch();
+        /* Clear out all prompts and such */
+        clear_warning();
+        for( i = y; i < ylast; i ++ )
+        {
+            move( i, x );
+            clrtoeol();
+        }
+        move( WARNING_START + 1, 0 );
+        clrtoeol();
+        /* Cursor keys */
+        if( key == ESC )
+        {
+            /* Check whether this is a real ESC or one of extended keys */
+            /*nodelay(stdscr, TRUE);*/
+            key = getch();
+            /*nodelay(stdscr, FALSE);*/
+            if( key == /*ERR*/ ESC )
+            {
+                /* This is a real ESC */
+                key = ESC;
+            }
+            if( key == '[' )
+            {
+                /* This is one extended keys */
+                switch( getch() )
+                {
+                    case 'A': /* Up arrow */
+                        if( menuType & MENU_VERT )
+                        {
+                            do {
+                                current -- ;
+                                if( current < 0 ) while( menuItems[current+1].key ) current ++ ;
+                            } while( !strchr( available, menuItems[current].key ) );
+                            key = 0;
+                        }
+                        else
+                            key = MENU_UP;
+                        break;
+                    case 'B': /* Down arrow */
+                        if( menuType & MENU_VERT )
+                        {
+                            do {
+                                current ++ ;
+                                if( !menuItems[current].key ) current = 0 ;
+                            } while( !strchr( available, menuItems[current].key ) );
+                            key = 0;
+                        }
+                        else
+                            key = MENU_DOWN;
+                        break;
+                    case 'C': /* Right arrow */
+                        if( menuType & MENU_HORIZ )
+                        {
+                            do {
+                                current ++ ;
+                                if( !menuItems[current].key ) 
+                                {
+                                    current = 0 ;
+                                }
+                            } while( !strchr( available, menuItems[current].key ) );
+                            key = 0;
+                        }
+                        else
+                            key = MENU_RIGHT;
+                        break;
+                    case 'D': /* Left arrow */
+                        if( menuType & MENU_HORIZ )
+                        {
+                            do {
+                                current -- ;
+                                if( current < 0 )
+                                {
+                                    while( menuItems[current + 1].key ) current ++ ;
+                                }
+                            } while( !strchr( available, menuItems[current].key ) );
+                            key = 0;
+                        }
+                        else
+                            key = MENU_LEFT;
+                        break;
+                }
+            }
+        }
+        /* Enter equals to the keyboard shortcut of current menu item */
+        if( key == 13 )
+        {
+            key = menuItems[current].key;
+        }
+        /* Should all keys to be accepted? */
+        if( key && (menuType & MENU_ACCEPT_OTHERS) ) break;
+        /* Is pressed key among acceptable ones */
+        if( key && (strchr(available, tolower(key)) || strchr(available, key)))
+	    break;
+        /* The key has not been accepted so far -> let's reject it */
+        if( key )
+        {
+            key = 0;
+            putchar( BELL );
+            print_warning("Illegal key");
+        }
+    }
+    /* Clear out prompts and such */
+    clear_warning();
+    for( i = y; i <= ylast; i ++ )
+    {
+        move( i, x );
+        clrtoeol();
+    }
+    move( WARNING_START + 1, 0 );
+    clrtoeol();
+    return key;
+}
+
+/* A function which displays "Press a key to continue"                  *
+ * and waits for a keypress.                                            *
+ * Perhaps calling function menuSelect is a bit overkill but who cares? */
+
+void menuContinue(void)
+{
+    static struct MenuItem menuContinueBtn[]=
+    {
+        { 'c', "", "Press a key to continue" },
+        { 0, NULL, NULL }
+    };
+
+    menuSelect(COMMAND_LINE_Y, COMMAND_LINE_X,
+	menuContinueBtn, 0, "c", MENU_HORIZ | MENU_ACCEPT_OTHERS, 0 );
+}
+
+/* Function menuSelect takes way too many parameters  *
+ * Luckily, most of time we can do with this function */
+
+int menuSimple(struct MenuItem *menuItems, int menuDefault)
+{
+    int i, j, itemLength = 0;
+    char available[MENU_MAX_ITEMS];
+    for(i = 0; menuItems[i].key; i++)
+    {
+        j = strlen( menuItems[i].name );
+        if( j > itemLength ) itemLength = j;
+        available[i] = menuItems[i].key;
+    }
+    available[i] = 0;
+    return menuSelect(COMMAND_LINE_Y, COMMAND_LINE_X, menuItems, itemLength,
+        available, MENU_HORIZ | MENU_BUTTON, menuDefault);
+}
+
+/* End of command menu support code */
+
+void new_part(int i)
+{
+    char response[LINE_LENGTH], def[LINE_LENGTH];
+    char c;
+    int first = p_info[i].first_sector;
+    int last = p_info[i].last_sector;
+    int offset = 0;
+    int flags = 0;
+    int id = LINUX;
+    int num = -1;
+    int num_sects = last - first + 1;
+    int len, ext, j;
+
+    if (p_info[i].num == PRI_OR_LOG) {
+        static struct MenuItem menuPartType[]=
+        {
+            { 'p', "Primary", "Create a new primary partition" },
+            { 'l', "Logical", "Create a new logical partition" },
+            { ESC, "Cancel", "Don't create a partition" },
+            { 0, NULL, NULL }
+        };
+        
+	c = menuSimple( menuPartType, 0 );
+	if (toupper(c) == 'P')
+	    num = find_primary();
+	else if (toupper(c) == 'L')
+	    num = find_logical(i);
+	else
+	    return;
+    } else if (p_info[i].num == PRIMARY)
+	num = find_primary();
+    else if (p_info[i].num == LOGICAL)
+	num = find_logical(i);
+    else
+	print_warning("!!! Internal error !!!");
+
+    sprintf(def, "%.2f", ceiling(num_sects/20.48)/100);
+    mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X, "Size (in MB): ");
+    if ((len = get_string(response, LINE_LENGTH, def)) <= 0 &&
+	len != GS_DEFAULT)
+	return;
+    else if (len > 0) {
+#define num_cyls(bytes) (round_int(bytes/SECTOR_SIZE/(sectors*heads)))
+	for (j = 0;
+	     j < len-1 && (isdigit(response[j]) || response[j] == '.');
+	     j++);
+	if (toupper(response[j]) == 'K') {
+	    num_sects = num_cyls(atof(response)*1024)*sectors*heads;
+	} else if (toupper(response[j]) == 'M') {
+	    num_sects = num_cyls(atof(response)*1024*1024)*sectors*heads;
+	} else if (toupper(response[j]) == 'C') {
+	    num_sects = round_int(atof(response))*sectors*heads;
+	} else if (toupper(response[j]) == 'S') {
+	    num_sects = round_int(atof(response));
+	} else {
+	    num_sects = num_cyls(atof(response)*1024*1024)*sectors*heads;
+	}
+    }
+
+    if (num_sects <= 0 ||
+	num_sects > p_info[i].last_sector - p_info[i].first_sector + 1)
+	return;
+
+    move( COMMAND_LINE_Y, COMMAND_LINE_X ); clrtoeol();
+    if (num_sects < p_info[i].last_sector - p_info[i].first_sector + 1) {
+	/* Determine where inside free space to put partition.
+	 */
+	static struct MenuItem menuPlace[]=
+	{
+	    { 'b', "Beginning", "Add partition at beginning of free space" },
+	    { 'e', "End", "Add partition at end of free space" },
+	    { ESC, "Cancel", "Don't create a partition" },
+	    { 0, NULL, NULL }
+	};
+	c = menuSimple( menuPlace, 0 );
+	if (toupper(c) == 'B')
+	    last = first + num_sects - 1;
+	else if (toupper(c) == 'E')
+	    first = last - num_sects + 1;
+	else
+	    return;
+    }
+
+    if (IS_LOGICAL(num) && !is_extended(ext_info.id)) {
+	/* We want to add a logical partition, but need to create an
+	 * extended partition first.
+	 */
+	if ((ext = find_primary()) < 0) {
+	    print_warning(NEED_EXT);
+	    return;
+	}
+	(void) add_part(ext, DOS_EXTENDED, 0, first, last,
+		       (first == 0 ? sectors : 0), 0);
+	first = ext_info.first_sector + ext_info.offset;
+    }
+
+    if (IS_LOGICAL(num))
+	inc_logical(i);
+
+    /* Now we have a complete partition to ourselves */
+    if (first == 0 || IS_LOGICAL(num))
+	offset = sectors;
+
+    (void) add_part(num, id, flags, first, last, offset, 0);
+}
+
+void clear_p_info(void)
+{
+    num_parts = 1;
+    p_info[0].first_sector = 0;
+    p_info[0].last_sector = sectors*heads*cylinders - 1;
+    p_info[0].offset = 0;
+    p_info[0].flags = 0;
+    p_info[0].id = FREE_SPACE;
+    p_info[0].num = PRI_OR_LOG;
+
+    ext_info.first_sector = 0;
+    ext_info.last_sector = 0;
+    ext_info.offset = 0;
+    ext_info.flags = 0;
+    ext_info.id = FREE_SPACE;
+    ext_info.num = PRIMARY;
+}
+
+void fill_p_info(void)
+{
+    int pn, i, bs, bsz;
+    struct partition *p;
+    struct hd_geometry geometry;
+    partition_table buffer;
+    partition_info tmp_ext = { 0, 0, 0, 0, FREE_SPACE, PRIMARY };
+
+    if ((fd = open(disk_device, O_RDWR)) < 0) {
+	 if ((fd = open(disk_device, O_RDONLY)) < 0)
+	      fatal(BAD_OPEN, 2);
+	 opentype = O_RDONLY;
+	 print_warning(READONLY_WARN);
+	 if (curses_started) {
+	      refresh();
+	      getch();
+	      clear_warning();
+	 }
+    } else
+	 opentype = O_RDWR;
+    opened = TRUE;
+
+    /* Blocks are visible in more than one way:
+       e.g. as block on /dev/hda and as block on /dev/hda3
+       By a bug in the Linux buffer cache, we will see the old
+       contents of /dev/hda when the change was made to /dev/hda3.
+       In order to avoid this, discard all blocks on /dev/hda.
+       Note that partition table blocks do not live in /dev/hdaN,
+       so this only plays a role if we want to show volume labels. */
+    ioctl(fd, BLKFLSBUF);	/* ignore errors */
+				/* e.g. Permission Denied */
+
+    if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
+	if (!heads)
+	    heads = geometry.heads;
+	if (!sectors)
+	    sectors = geometry.sectors;
+	if (!cylinders)
+	    cylinders = geometry.cylinders;
+    }
+
+    if (!heads || !sectors || !cylinders)
+	fatal(BAD_GEOMETRY, 3);	/* probably a file or cdrom */
+
+    read_sector(buffer.c.b, 0);
+
+    clear_p_info();
+
+    if (!zero_table) {
+	for (i = 0; i < 4; i++) {
+	    p = & buffer.p.part[i];
+	    bs = get_start_sect(p);
+	    bsz = get_nr_sects(p);
+
+	    if (p->sys_ind > 0 &&
+		add_part(i, p->sys_ind, p->boot_ind,
+			 ((bs <= sectors) ? 0 : bs),
+			 bs + bsz - 1,
+			 ((bs <= sectors) ? bs : 0),
+			 1)) {
+		fatal(BAD_PRIMARY, 4);
+	    }
+	    if (is_extended(buffer.p.part[i].sys_ind))
+		tmp_ext = ext_info;
+	}
+
+	if (is_extended(tmp_ext.id)) {
+	    ext_info = tmp_ext;
+	    logical_sectors[logical] =
+		 ext_info.first_sector + ext_info.offset;
+	    read_sector(buffer.c.b, logical_sectors[logical++]);
+	    i = 4;
+	    do {
+		for (pn = 0;
+		     pn < 4 && (!buffer.p.part[pn].sys_ind ||
+			       is_extended(buffer.p.part[pn].sys_ind));
+		     pn++);
+
+		if (pn < 4) {
+			p = & buffer.p.part[pn];
+			bs = get_start_sect(p);
+			bsz = get_nr_sects(p);
+
+			if (add_part(i++, p->sys_ind, p->boot_ind,
+			     logical_sectors[logical-1],
+			     logical_sectors[logical-1] + bs + bsz - 1,
+			     bs, 1))
+				fatal(BAD_LOGICAL, 4);
+		}
+
+		for (pn = 0;
+		     pn < 4 && !is_extended(buffer.p.part[pn].sys_ind);
+		     pn++);
+		if (pn < 4) {
+			p = & buffer.p.part[pn];
+			bs = get_start_sect(p);
+			logical_sectors[logical] = ext_info.first_sector
+				+ ext_info.offset + bs;
+			read_sector(buffer.c.b, logical_sectors[logical++]);
+		}
+	    } while (pn < 4 && logical < MAXIMUM_PARTS-4);
+	}
+    }
+}
+
+void fill_part_table(struct partition *p, partition_info *pi)
+{
+    int sects;
+
+    p->boot_ind = pi->flags;
+    p->sys_ind = pi->id;
+    if (IS_LOGICAL(pi->num))
+	set_start_sect(p,pi->offset);
+    else
+	set_start_sect(p,pi->first_sector + pi->offset);
+    set_nr_sects(p, pi->last_sector - (pi->first_sector+pi->offset) + 1);
+    sects = (((pi->first_sector+pi->offset)/(sectors*heads) > 1023) ?
+	     heads*sectors*1024 - 1 : pi->first_sector+pi->offset);
+    set_hsc(p->head, p->sector, p->cyl, sects);
+    sects = ((pi->last_sector/(sectors*heads) > 1023) ?
+	     heads*sectors*1024 - 1 : pi->last_sector);
+    set_hsc(p->end_head, p->end_sector, p->end_cyl, sects);
+}
+
+void fill_primary_table(partition_table *buffer)
+{
+    int i;
+
+    /* Zero out existing table */
+    for (i = 0x1BE; i < SECTOR_SIZE; i++)
+	buffer->c.b[i] = 0;
+
+    for (i = 0; i < num_parts; i++)
+	if (IS_PRIMARY(p_info[i].num))
+	    fill_part_table(&(buffer->p.part[p_info[i].num]), &(p_info[i]));
+
+    if (is_extended(ext_info.id))
+	fill_part_table(&(buffer->p.part[ext_info.num]), &ext_info);
+
+    buffer->p.magicflag[0] = PART_TABLE_FLAG0;
+    buffer->p.magicflag[1] = PART_TABLE_FLAG1;
+}
+
+void fill_logical_table(partition_table *buffer, partition_info *pi)
+{
+    struct partition *p;
+    int i, sects;
+
+    for (i = 0; i < logical && pi->first_sector != logical_sectors[i]; i++);
+    if (i == logical || buffer->p.magicflag[0] != PART_TABLE_FLAG0
+	             || buffer->p.magicflag[1] != PART_TABLE_FLAG1)
+	for (i = 0; i < SECTOR_SIZE; i++)
+	    buffer->c.b[i] = 0;
+
+    /* Zero out existing table */
+    for (i = 0x1BE; i < SECTOR_SIZE; i++)
+	buffer->c.b[i] = 0;
+
+    fill_part_table(&(buffer->p.part[0]), pi);
+
+    for (i = 0;
+	 i < num_parts && pi->num != p_info[i].num - 1;
+	 i++);
+
+    if (i < num_parts) {
+	p = &(buffer->p.part[1]);
+	pi = &(p_info[i]);
+
+	p->boot_ind = 0;
+	p->sys_ind = DOS_EXTENDED;
+	set_start_sect(p, pi->first_sector - ext_info.first_sector - ext_info.offset);
+	set_nr_sects(p, pi->last_sector - pi->first_sector + 1);
+	sects = ((pi->first_sector/(sectors*heads) > 1023) ?
+		 heads*sectors*1024 - 1 : pi->first_sector);
+	set_hsc(p->head, p->sector, p->cyl, sects);
+	sects = ((pi->last_sector/(sectors*heads) > 1023) ?
+		 heads*sectors*1024 - 1 : pi->last_sector);
+	set_hsc(p->end_head, p->end_sector, p->end_cyl, sects);
+    }
+
+    buffer->p.magicflag[0] = PART_TABLE_FLAG0;
+    buffer->p.magicflag[1] = PART_TABLE_FLAG1;
+}
+
+void write_part_table(void)
+{
+    int i, ct, done = FALSE, len;
+    partition_table buffer;
+    struct stat s;
+    int is_bdev;
+    char response[LINE_LENGTH];
+
+    if (opentype == O_RDONLY) {
+	 print_warning(READONLY_WARN);
+	 refresh();
+	 getch();
+	 clear_warning();
+	 return;
+    }
+
+    is_bdev = 0;
+    if(fstat(fd, &s) == 0 && S_ISBLK(s.st_mode))
+	 is_bdev = 1;
+
+    if (is_bdev) {
+	 print_warning(WRITE_WARN);
+
+	 while (!done) {
+	      mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X,
+		       "Are you sure you want write the partition table "
+		       "to disk? (yes or no): ");
+	      len = get_string(response, LINE_LENGTH, NULL);
+	      clear_warning();
+	      if (len == GS_ESCAPE)
+		   return;
+	      else if (len == 2 &&
+		       toupper(response[0]) == 'N' &&
+		       toupper(response[1]) == 'O') {
+		   print_warning(NO_WRITE);
+		   return;
+	      } else if (len == 3 &&
+			 toupper(response[0]) == 'Y' &&
+			 toupper(response[1]) == 'E' &&
+			 toupper(response[2]) == 'S')
+		   done = TRUE;
+	      else
+		   print_warning(YES_NO);
+	 }
+
+	 clear_warning();
+	 print_warning(WRITING_PART);
+	 refresh();
+    }
+
+    read_sector(buffer.c.b, 0);
+    fill_primary_table(&buffer);
+    write_sector(buffer.c.b, 0);
+
+    for (i = 0; i < num_parts; i++)
+	if (IS_LOGICAL(p_info[i].num)) {
+	    read_sector(buffer.c.b, p_info[i].first_sector);
+	    fill_logical_table(&buffer, &(p_info[i]));
+	    write_sector(buffer.c.b, p_info[i].first_sector);
+	}
+
+    if (is_bdev) {
+	 sync();
+	 sleep(2);
+	 if (!ioctl(fd,BLKRRPART))
+	      changed = TRUE;
+	 sync();
+	 sleep(4);
+
+	 clear_warning();
+	 if (changed)
+	      print_warning(YES_WRITE);
+	 else
+	      print_warning(RRPART_FAILED);
+    } else
+	 print_warning(YES_WRITE);
+
+    /* Check: unique bootable primary partition? */
+    ct = 0;
+    for (i = 0; i < num_parts; i++)
+	if (IS_PRIMARY(i) && p_info[i].flags == ACTIVE_FLAG)
+	    ct++;
+    if (ct != 1)
+	print_warning(NOT_DOS_MBR_BOOTABLE);
+}
+
+void fp_printf(FILE *fp, char *format, ...)
+{
+    va_list args;
+    char buf[1024];
+    int y, x;
+
+    va_start(args, format);
+    vsprintf(buf, format, args);
+    va_end(args);
+
+    if (fp == NULL) {
+	/* The following works best if the string to be printed has at
+           most only one newline. */
+	printw("%s", buf);
+	getyx(stdscr, y, x);
+	if (y >= COMMAND_LINE_Y-2) {
+	    menuContinue();
+	    erase();
+	    move(0, 0);
+	}
+    } else
+	fprintf(fp, "%s", buf);
+}
+
+#define MAX_PER_LINE 16
+void print_file_buffer(FILE *fp, char *buffer)
+{
+    int i,l;
+
+    for (i = 0, l = 0; i < SECTOR_SIZE; i++, l++) {
+	if (l == 0)
+	    fp_printf(fp, "0x%03X:", i);
+	fp_printf(fp, " %02X", (unsigned char) buffer[i]);
+	if (l == MAX_PER_LINE - 1) {
+	    fp_printf(fp, "\n");
+	    l = -1;
+	}
+    }
+    if (l > 0)
+	fp_printf(fp, "\n");
+    fp_printf(fp, "\n");
+}
+
+void print_raw_table(void)
+{
+    int i, to_file;
+    partition_table buffer;
+    char fname[LINE_LENGTH];
+    FILE *fp;
+
+    if (print_only) {
+	fp = stdout;
+	to_file = TRUE;
+    } else {
+	mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X,
+		 "Enter filename or press RETURN to display on screen: ");
+
+	if ((to_file = get_string(fname, LINE_LENGTH, NULL)) < 0)
+	    return;
+
+	if (to_file) {
+	    if ((fp = fopen(fname, "w")) == NULL) {
+		char errstr[LINE_LENGTH];
+		sprintf(errstr, PRINT_OPEN_ERR, fname);
+		print_warning(errstr);
+		return;
+	    }
+	} else {
+	    fp = NULL;
+	    erase();
+	    move(0, 0);
+	}
+    }
+
+    fp_printf(fp, "Disk Drive: %s\n", disk_device);
+
+    fp_printf(fp, "Sector 0:\n");
+    read_sector(buffer.c.b, 0);
+    fill_primary_table(&buffer);
+    print_file_buffer(fp, buffer.c.b);
+
+    for (i = 0; i < num_parts; i++)
+	if (IS_LOGICAL(p_info[i].num)) {
+	    fp_printf(fp, "Sector %d:\n", p_info[i].first_sector);
+	    read_sector(buffer.c.b, p_info[i].first_sector);
+	    fill_logical_table(&buffer, &(p_info[i]));
+	    print_file_buffer(fp, buffer.c.b);
+	}
+
+    if (to_file) {
+	if (!print_only)
+	    fclose(fp);
+    } else {
+        menuContinue();
+    }
+}
+
+void print_p_info_entry(FILE *fp, partition_info *p)
+{
+    int size;
+    char part_str[40];
+
+    if (p->id == UNUSABLE)
+	fp_printf(fp, "   None   ");
+    else if (p->id == FREE_SPACE && p->num == PRI_OR_LOG)
+	fp_printf(fp, "   Pri/Log");
+    else if (p->id == FREE_SPACE && p->num == PRIMARY)
+	fp_printf(fp, "   Primary");
+    else if (p->id == FREE_SPACE && p->num == LOGICAL)
+	fp_printf(fp, "   Logical");
+    else
+	fp_printf(fp, "%2d %-7.7s", p->num+1,
+		  IS_LOGICAL(p->num) ? "Logical" : "Primary");
+
+    fp_printf(fp, " ");
+
+    fp_printf(fp, "%8d%c", p->first_sector,
+	      ((p->first_sector/(sectors*heads)) !=
+	       ((float)p->first_sector/(sectors*heads)) ?
+	       '*' : ' '));
+
+    fp_printf(fp, "%8d%c", p->last_sector,
+	      (((p->last_sector+1)/(sectors*heads)) !=
+	       ((float)(p->last_sector+1)/(sectors*heads)) ?
+	       '*' : ' '));
+
+    fp_printf(fp, "%7d%c", p->offset,
+	      ((((p->first_sector == 0 || IS_LOGICAL(p->num)) &&
+		 (p->offset != sectors)) ||
+		(p->first_sector != 0 && IS_PRIMARY(p->num) &&
+		 p->offset != 0)) ?
+	       '#' : ' '));
+
+    size = p->last_sector - p->first_sector + 1;
+    fp_printf(fp, "%8d%c", size,
+	      ((size/(sectors*heads)) != ((float)size/(sectors*heads)) ?
+	       '*' : ' '));
+
+    fp_printf(fp, " ");
+
+    if (p->id == UNUSABLE)
+	sprintf(part_str, "%.17s", "Unusable");
+    else if (p->id == FREE_SPACE)
+	sprintf(part_str, "%.17s", "Free Space");
+    else if (partition_type[p->id])
+	sprintf(part_str, "%.17s (%02X)", partition_type[p->id], p->id);
+    else
+	sprintf(part_str, "%.17s (%02X)", "Unknown", p->id);
+    fp_printf(fp, "%-22.22s", part_str);
+
+    fp_printf(fp, " ");
+
+    if (p->flags == ACTIVE_FLAG)
+	fp_printf(fp, "Boot (%02X)", p->flags);
+    else if (p->flags != 0)
+	fp_printf(fp, "Unknown (%02X)", p->flags);
+    else
+	fp_printf(fp, "None (%02X)", p->flags);
+
+    fp_printf(fp, "\n");
+}
+
+void print_p_info(void)
+{
+    char fname[LINE_LENGTH];
+    FILE *fp;
+    int i, to_file, pext = is_extended(ext_info.id);
+
+    if (print_only) {
+	fp = stdout;
+	to_file = TRUE;
+    } else {
+	mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X,
+		 "Enter filename or press RETURN to display on screen: ");
+
+	if ((to_file = get_string(fname, LINE_LENGTH, NULL)) < 0)
+	    return;
+
+	if (to_file) {
+	    if ((fp = fopen(fname, "w")) == NULL) {
+		char errstr[LINE_LENGTH];
+		sprintf(errstr, PRINT_OPEN_ERR, fname);
+		print_warning(errstr);
+		return;
+	    }
+	} else {
+	    fp = NULL;
+	    erase();
+	    move(0, 0);
+	}
+    }
+
+    fp_printf(fp, "Partition Table for %s\n", disk_device);
+    fp_printf(fp, "\n");
+    fp_printf(fp, "            First    Last\n");
+    fp_printf(fp, " # Type     Sector   Sector   Offset  Length   Filesystem Type (ID)   Flags\n");
+    fp_printf(fp, "-- ------- -------- --------- ------ --------- ---------------------- ---------\n");
+
+    for (i = 0; i < num_parts; i++) {
+	if (pext && (p_info[i].first_sector >= ext_info.first_sector)) {
+	    print_p_info_entry(fp,&ext_info);
+	    pext = FALSE;
+	}
+	print_p_info_entry(fp, &(p_info[i]));
+    }
+
+    if (to_file) {
+	if (!print_only)
+	    fclose(fp);
+    } else {
+        menuContinue();
+    }
+}
+
+void print_part_entry(FILE *fp, int num, partition_info *pi)
+{
+    int first = 0, start = 0, end = 0, size = 0;
+    int ss = 0, sh = 0, sc = 0;
+    int es = 0, eh = 0, ec = 0;
+    int flags = 0, id = 0;
+
+    if (pi != NULL) {
+	flags = pi->flags;
+	id = pi->id;
+
+	if (IS_LOGICAL(num))
+	    first = pi->offset;
+	else
+	    first = pi->first_sector + pi->offset;
+
+	start = pi->first_sector + pi->offset;
+	end = pi->last_sector;
+	size = end - start + 1;
+	if ((start/(sectors*heads)) > 1023)
+	    start = heads*sectors*1024 - 1;
+	if ((end/(sectors*heads)) > 1023)
+	    end = heads*sectors*1024 - 1;
+
+	ss = start % sectors + 1;
+	start /= sectors;
+	sh = start % heads;
+	sc = start / heads;
+
+	es = end % sectors + 1;
+	end /= sectors;
+	eh = end % heads;
+	ec = end / heads;
+    }
+
+    fp_printf(fp, "%2d  0x%02X %4d %4d %4d 0x%02X %4d %4d %4d %8d %9d\n",
+	      num+1, flags, sh, ss, sc, id, eh, es, ec, first, size);
+}
+
+
+void print_part_table(void)
+{
+    int i, j, to_file;
+    char fname[LINE_LENGTH];
+    FILE *fp;
+
+    if (print_only) {
+	fp = stdout;
+	to_file = TRUE;
+    } else {
+	mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X,
+		 "Enter filename or press RETURN to display on screen: ");
+
+	if ((to_file = get_string(fname, LINE_LENGTH, NULL)) < 0)
+	    return;
+
+	if (to_file) {
+	    if ((fp = fopen(fname, "w")) == NULL) {
+		char errstr[LINE_LENGTH];
+		sprintf(errstr, PRINT_OPEN_ERR, fname);
+		print_warning(errstr);
+		return;
+	    }
+	} else {
+	    fp = NULL;
+	    erase();
+	    move(0, 0);
+	}
+    }
+
+    fp_printf(fp, "Partition Table for %s\n", disk_device);
+    fp_printf(fp, "\n");
+    fp_printf(fp, "         ---Starting---      ----Ending----    Start Number of\n");
+    fp_printf(fp, " # Flags Head Sect Cyl   ID  Head Sect Cyl    Sector  Sectors\n");
+    fp_printf(fp, "-- ----- ---- ---- ---- ---- ---- ---- ---- -------- ---------\n");
+
+    for (i = 0; i < 4; i++) {
+	for (j = 0;
+	     j < num_parts && (p_info[j].id <= 0 || p_info[j].num != i);
+	     j++);
+	if (j < num_parts) {
+	    print_part_entry(fp, i, &(p_info[j]));
+	} else if (is_extended(ext_info.id) && ext_info.num == i) {
+	    print_part_entry(fp, i, &ext_info);
+	} else {
+	    print_part_entry(fp, i, NULL);
+	}
+    }
+
+    for (i = 0; i < num_parts; i++)
+	if (IS_LOGICAL(p_info[i].num))
+	    print_part_entry(fp, p_info[i].num, &(p_info[i]));
+
+    if (to_file) {
+	if (!print_only)
+	    fclose(fp);
+    } else {
+        menuContinue();
+    }
+}
+
+void print_tables(void)
+{
+    int done = FALSE;
+
+    static struct MenuItem menuFormat[]=
+    {
+        { 'r', "Raw", "Print the table using raw data format" },
+        { 's', "Sectors", "Print the table ordered by sectors" },
+        { 't', "Table", "Just print the partition table" },
+        { ESC, "Cancel", "Don't print the table" },
+        { 0, NULL, NULL }
+    };
+    
+    while (!done)
+	switch ( toupper(menuSimple( menuFormat, 2)) ) {
+	case 'R':
+	    print_raw_table();
+	    done = TRUE;
+	    break;
+	case 'S':
+	    print_p_info();
+	    done = TRUE;
+	    break;
+	case 'T':
+	    print_part_table();
+	    done = TRUE;
+	    break;
+	case ESC:
+	    done = TRUE;
+	    break;
+	}
+}
+
+#define END_OF_HELP "EOHS!"
+#define NEW_HELP_SCREEN "SNHS!"
+void display_help()
+{
+    char *help_text[] = {
+	"Help Screen for cfdisk " VERSION,
+	"",
+	"This is cfdisk, a curses based disk partitioning programs, which",
+	"allows you to create, delete and modify partitions on your hard",
+	"disk drive.",
+	"",
+	"Copyright (C) 1994-1998 Kevin E. Martin & aeb",
+	"",
+	"Command      Meaning",
+	"-------      -------",
+	"  b          Toggle bootable flag of the current partition",
+	"  d          Delete the current partition",
+	"  g          Change cylinders, heads, sectors-per-track parameters",
+	"             WARNING: This option should only be used by people who",
+	"             know what they are doing.",
+	"  h          Print this screen",
+	"  m          Maximize disk usage of the current partition",
+	"             Note: This may make the partition incompatible with",
+	"             DOS, OS/2, ...",
+	"  n          Create new partition from free space",
+	"  p          Print partition table to the screen or to a file",
+	"             There are several different formats for the partition",
+	"             that you can choose from:",
+	"                r - Raw data (exactly what would be written to disk)",
+	"                s - Table ordered by sectors",
+	"                t - Table in raw format",
+	"  q          Quit program without writing partition table",
+	"  t          Change the filesystem type",
+	"  u          Change units of the partition size display",
+	"             Rotates through Mb, sectors and cylinders",
+	"  W          Write partition table to disk (must enter upper case W)",
+        "             Since this might destroy data on the disk, you must",
+	"             either confirm or deny the write by entering `yes' or",
+	"             `no'",
+	"Up Arrow     Move cursor to the previous partition",
+	"Down Arrow   Move cursor to the next partition",
+	"CTRL-L       Redraws the screen",
+	"  ?          Print this screen",
+	"",
+	"Note: All of the commands can be entered with either upper or lower",
+	"case letters (except for Writes).",
+	END_OF_HELP
+    };
+
+    int cur_line = 0;
+    FILE *fp = NULL;
+
+    erase();
+    move(0, 0);
+    while (strcmp(help_text[cur_line], END_OF_HELP))
+	if (!strcmp(help_text[cur_line], NEW_HELP_SCREEN)) {
+	    menuContinue();
+	    erase();
+	    move(0, 0);
+	    cur_line++;
+	} else
+	    fp_printf(fp, "%s\n", help_text[cur_line++]);
+
+    menuContinue();
+}
+
+int change_geometry(void)
+{
+    int ret_val = FALSE;
+    int done = FALSE;
+    char def[LINE_LENGTH];
+    char response[LINE_LENGTH];
+    int tmp_val;
+
+    while (!done) {
+        static struct MenuItem menuGeometry[]=
+        {
+            { 'c', "Cylinders", "Change cylinder geometry" },
+            { 'h', "Heads", "Change head geometry" },
+            { 's', "Sectors", "Change sector geometry" },
+            { 'd', "Done", "Done with changing geometry" },
+            { 0, NULL, NULL }
+        };
+	move(COMMAND_LINE_Y, COMMAND_LINE_X);
+	clrtoeol();
+	refresh();
+
+	clear_warning();
+
+	switch (toupper( menuSimple(menuGeometry, 3) )) {
+	case 'C':
+	    sprintf(def, "%d", cylinders);
+	    mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X,
+		     "Enter the number of cylinders: ");
+	    if (get_string(response, LINE_LENGTH, def) > 0) {
+		tmp_val = atoi(response);
+		if (tmp_val > 0 && tmp_val <= MAX_CYLINDERS) {
+		    cylinders = tmp_val;
+		    ret_val = TRUE;
+		} else
+		    print_warning(BAD_CYLINDERS);
+	    }
+	    break;
+	case 'H':
+	    sprintf(def, "%d", heads);
+	    mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X,
+		     "Enter the number of heads: ");
+	    if (get_string(response, LINE_LENGTH, def) > 0) {
+		tmp_val = atoi(response);
+		if (tmp_val > 0 && tmp_val <= MAX_HEADS) {
+		    heads = tmp_val;
+		    ret_val = TRUE;
+		} else
+		    print_warning(BAD_HEADS);
+	    }
+	    break;
+	case 'S':
+	    sprintf(def, "%d", sectors);
+	    mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X,
+		     "Enter the number of sectors per track: ");
+	    if (get_string(response, LINE_LENGTH, def) > 0) {
+		tmp_val = atoi(response);
+		if (tmp_val > 0 && tmp_val <= MAX_SECTORS) {
+		    sectors = tmp_val;
+		    ret_val = TRUE;
+		} else
+		    print_warning(BAD_SECTORS);
+	    }
+	    break;
+	case ESC:
+	case 'D':
+	    done = TRUE;
+	    break;
+	default:
+	    putchar(BELL);
+	    break;
+	}
+    }
+
+    if (ret_val) {
+	int disk_end = heads*sectors*cylinders-1;
+
+	if (p_info[num_parts-1].last_sector > disk_end) {
+	    while (p_info[num_parts-1].first_sector > disk_end) {
+		if (p_info[num_parts-1].id == FREE_SPACE ||
+		    p_info[num_parts-1].id == UNUSABLE)
+		    remove_part(num_parts-1);
+		else
+		    del_part(num_parts-1);
+	    }
+
+	    p_info[num_parts-1].last_sector = disk_end;
+
+	    if (ext_info.last_sector > disk_end)
+		ext_info.last_sector = disk_end;
+	} else if (p_info[num_parts-1].last_sector < disk_end) {
+	    if (p_info[num_parts-1].id == FREE_SPACE ||
+		p_info[num_parts-1].id == UNUSABLE) {
+		p_info[num_parts-1].last_sector = disk_end;
+	    } else {
+		insert_empty_part(num_parts,
+				  p_info[num_parts-1].last_sector+1,
+				  disk_end);
+	    }
+	}
+
+	/* Make sure the partitions are correct */
+	check_part_info();
+    }
+
+    return ret_val;
+}
+
+void change_id(int i)
+{
+    char id[LINE_LENGTH], def[LINE_LENGTH];
+    int num_types = 0;
+    int num_across, num_down;
+    int len, new_id = ((p_info[i].id == LINUX) ? LINUX_SWAP : LINUX);
+    int y_start, y_end;
+    int j, pos;
+
+    for (num_types = 0, j = 1; j < NUM_PART_TYPES; j++)
+	if (partition_type[j])
+	    num_types++;
+
+    num_across = COLS/COL_ID_WIDTH;
+    num_down = (((float)num_types)/num_across + 1);
+    y_start = COMMAND_LINE_Y - 1 - num_down;
+    if (y_start > DISK_TABLE_START+cur_part+4)
+	y_start = DISK_TABLE_START+cur_part+4;
+    y_end = y_start + num_down - 1;
+
+    for (j = y_start - 1; j <= y_end + 1; j++) {
+	move(j, 0);
+	clrtoeol();
+    }
+
+    for (pos = 0, j = 1; j < NUM_PART_TYPES; j++)
+	if (partition_type[j]) {
+	    move(y_start + pos % num_down, (pos/num_down)*COL_ID_WIDTH + 1);
+	    printw("%02X %-16.16s", j, partition_type[j]);
+	    pos++;
+	}
+
+    sprintf(def, "%02X", new_id);
+    mvaddstr(COMMAND_LINE_Y, COMMAND_LINE_X, "Enter filesystem type: ");
+    if ((len = get_string(id, 2, def)) <= 0 && len != GS_DEFAULT)
+	return;
+
+    if (len != GS_DEFAULT) {
+	if (!isxdigit(id[0]))
+	    return;
+	new_id = (isdigit(id[0]) ? id[0] - '0' : tolower(id[0]) - 'a' + 10);
+	if (len == 2) {
+	    if (isxdigit(id[1]))
+		new_id = new_id*16 +
+		    (isdigit(id[1]) ? id[1] - '0' : tolower(id[1]) - 'a' + 10);
+	    else
+		return;
+	}
+    }
+
+    if (new_id == 0)
+	print_warning(ID_EMPTY);
+    else if (is_extended(new_id))
+	print_warning(ID_EXT);
+    else
+	p_info[i].id = new_id;
+}
+
+void draw_partition(int i)
+{
+    int size, j;
+    int y = i + DISK_TABLE_START + 2 - (cur_part/NUM_ON_SCREEN)*NUM_ON_SCREEN;
+    char *t;
+
+    if (!arrow_cursor) {
+	move(y, 0);
+	for (j = 0; j < COLS; j++)
+	    addch(' ');
+    }
+
+    if (p_info[i].id > 0) {
+	mvprintw(y, NAME_START,
+		 "%s%d", my_basename(disk_device), p_info[i].num+1);
+	if (p_info[i].flags) {
+	    if (p_info[i].flags == ACTIVE_FLAG)
+		mvaddstr(y, FLAGS_START, "Boot");
+	    else
+		mvprintw(y, FLAGS_START, "Unk(%02X)", p_info[i].flags);
+	    if (p_info[i].first_sector == 0 || IS_LOGICAL(p_info[i].num)) {
+		if (p_info[i].offset != sectors)
+		    addstr(", NC");
+	    } else {
+		if (p_info[i].offset != 0)
+		    addstr(", NC");
+	    }
+	} else {
+	    if (p_info[i].first_sector == 0 || IS_LOGICAL(p_info[i].num)) {
+		if (p_info[i].offset != sectors)
+		    mvaddstr(y, FLAGS_START, "NC");
+	    } else {
+		if (p_info[i].offset != 0)
+		    mvaddstr(y, FLAGS_START, "NC");
+	    }
+	}
+    }
+    mvaddstr(y, PTYPE_START,
+	     (p_info[i].id == UNUSABLE ? "" :
+	      (IS_LOGICAL(p_info[i].num) ? "Logical" :
+	       (p_info[i].num >= 0 ? "Primary" :
+		(p_info[i].num == PRI_OR_LOG ? "Pri/Log" :
+		 (p_info[i].num == PRIMARY ? "Primary" : "Logical"))))));
+
+    t = partition_type_text(i);
+    if (t)
+	 mvaddstr(y, FSTYPE_START, t);
+    else
+	 mvprintw(y, FSTYPE_START, "Unknown (%02X)", p_info[i].id);
+
+    if (p_info[i].volume_label[0]) {
+	int l = strlen(p_info[i].volume_label);
+	int s = SIZE_START-5-l;
+	mvprintw(y, (s > LABEL_START) ? LABEL_START : s,
+		 " [%s]  ", p_info[i].volume_label);
+    }
+
+    size = p_info[i].last_sector - p_info[i].first_sector + 1;
+    if (display_units == SECTORS)
+	mvprintw(y, SIZE_START, "%9d", size);
+    else if (display_units == CYLINDERS)
+	mvprintw(y, SIZE_START, "%9d", size/(sectors*heads));
+    else
+	mvprintw(y, SIZE_START, "%9.2f", ceiling(size/20.48)/100);
+    if (((size/(sectors*heads)) != ceiling(size/(sectors*(float)heads))) ||
+	((p_info[i].first_sector/(sectors*heads)) !=
+	 ceiling(p_info[i].first_sector/(sectors*heads))))
+	mvprintw(y, COLUMNS-1, "*");
+}
+
+void init_const(void)
+{
+    if (!defined) {
+	NAME_START = (((float)NAME_START)/COLUMNS)*COLS;
+	FLAGS_START = (((float)FLAGS_START)/COLUMNS)*COLS;
+	PTYPE_START = (((float)PTYPE_START)/COLUMNS)*COLS;
+	FSTYPE_START = (((float)FSTYPE_START)/COLUMNS)*COLS;
+	LABEL_START = (((float)LABEL_START)/COLUMNS)*COLS;
+	SIZE_START = (((float)SIZE_START)/COLUMNS)*COLS;
+	COMMAND_LINE_X = (((float)COMMAND_LINE_X)/COLUMNS)*COLS;
+
+	COMMAND_LINE_Y = LINES - 4;
+	WARNING_START = LINES - 2;
+
+	if ((NUM_ON_SCREEN = COMMAND_LINE_Y - DISK_TABLE_START - 3) <= 0)
+	    NUM_ON_SCREEN = 1;
+
+	COLUMNS = COLS;
+	defined = TRUE;
+    }
+}
+
+void draw_screen(void)
+{
+    int i;
+    char *line;
+
+    line = (char *)malloc((COLS+1)*sizeof(char));
+
+    if (warning_last_time) {
+	for (i = 0; i < COLS; i++) {
+	    move(WARNING_START, i);
+	    line[i] = inch();
+	}
+	line[COLS] = 0;
+    }
+
+    erase();
+
+    if (warning_last_time)
+	mvaddstr(WARNING_START, 0, line);
+
+
+    sprintf(line, "cfdisk %s", VERSION);
+    mvaddstr(HEADER_START, (COLS-strlen(line))/2, line);
+    sprintf(line, "Disk Drive: %s", disk_device);
+    mvaddstr(HEADER_START+2, (COLS-strlen(line))/2, line);
+    sprintf(line, "Heads: %d   Sectors per Track: %d   Cylinders: %d",
+	    heads, sectors, cylinders);
+    mvaddstr(HEADER_START+3, (COLS-strlen(line))/2, line);
+
+    mvaddstr(DISK_TABLE_START, NAME_START, "Name");
+    mvaddstr(DISK_TABLE_START, FLAGS_START, "Flags");
+    mvaddstr(DISK_TABLE_START, PTYPE_START-1, "Part Type");
+    mvaddstr(DISK_TABLE_START, FSTYPE_START, "FS Type");
+    mvaddstr(DISK_TABLE_START, LABEL_START+1, "[Label]");
+    if (display_units == SECTORS)
+	mvaddstr(DISK_TABLE_START, SIZE_START, "  Sectors");
+    else if (display_units == CYLINDERS)
+	mvaddstr(DISK_TABLE_START, SIZE_START, "Cylinders");
+    else
+	mvaddstr(DISK_TABLE_START, SIZE_START, "Size (MB)");
+
+    move(DISK_TABLE_START+1, 1);
+    for (i = 1; i < COLS-1; i++)
+	addch('-');
+
+    if (NUM_ON_SCREEN >= num_parts)
+	for (i = 0; i < num_parts; i++)
+	    draw_partition(i);
+    else
+	for (i = (cur_part/NUM_ON_SCREEN)*NUM_ON_SCREEN;
+	     i < NUM_ON_SCREEN + (cur_part/NUM_ON_SCREEN)*NUM_ON_SCREEN &&
+	     i < num_parts;
+	     i++)
+	    draw_partition(i);
+
+    free(line);
+}
+
+int draw_cursor(int move)
+{
+    if (move != 0 && (cur_part + move < 0 || cur_part + move >= num_parts))
+	return -1;
+
+    if (arrow_cursor)
+	mvaddstr(DISK_TABLE_START + cur_part + 2
+		 - (cur_part/NUM_ON_SCREEN)*NUM_ON_SCREEN, 0, "   ");
+    else
+	draw_partition(cur_part);
+
+    cur_part += move;
+
+    if (((cur_part - move)/NUM_ON_SCREEN)*NUM_ON_SCREEN !=
+	(cur_part/NUM_ON_SCREEN)*NUM_ON_SCREEN)
+	draw_screen();
+
+    if (arrow_cursor)
+	mvaddstr(DISK_TABLE_START + cur_part + 2
+		 - (cur_part/NUM_ON_SCREEN)*NUM_ON_SCREEN, 0, "-->");
+    else {
+	standout();
+	draw_partition(cur_part);
+	standend();
+    }
+
+    return 0;
+}
+
+void do_curses_fdisk(void)
+{
+    int done = FALSE;
+    char command;
+
+    static struct MenuItem menuMain[]=
+    {
+        { 'b', "Bootable", "Toggle bootable flag of the current partition" },
+        { 'd', "Delete", "Delete the current partition" },
+        { 'g', "Geometry", "Change disk geometry (experts only)" },
+        { 'h', "Help", "Print help screen" },
+        { 'm', "Maximize", "Maximize disk usage of the current partition (experts only)" },
+        { 'n', "New", "Create new partition from free space" },
+        { 'p', "Print", "Print partition table to the screen or to a file" },
+        { 'q', "Quit", "Quit program without writing partition table" },
+        { 't', "Type", "Change the filesystem type (DOS, Linux, OS/2 and so on)" },
+        { 'u', "Units", "Change units of the partition size display (MB, sect, cyl)" },
+        { 'W', "Write", "Write partition table to disk (this might destroy data)" },
+        { 0, NULL, NULL }
+    };
+    curses_started = 1;
+    initscr();
+    init_const();
+
+    old_SIGINT = signal(SIGINT, die);
+    old_SIGTERM = signal(SIGTERM, die);
+#ifdef DEBUG
+    signal(SIGINT, old_SIGINT);
+    signal(SIGTERM, old_SIGTERM);
+#endif
+
+    cbreak();
+    noecho();
+    nonl();
+
+    fill_p_info();
+
+    draw_screen();
+
+    while (!done) {
+	char *s;
+
+	(void)draw_cursor(0);
+
+	if (p_info[cur_part].id == FREE_SPACE) {
+	    s = ((opentype == O_RDWR) ? "hnpquW" : "hnpqu");
+	    command = menuSelect(COMMAND_LINE_Y, COMMAND_LINE_X, menuMain, 8,
+	        s, MENU_HORIZ | MENU_BUTTON | MENU_ACCEPT_OTHERS, 0);
+	} else if (p_info[cur_part].id > 0) {
+	    s = ((opentype == O_RDWR) ? "bdhmpqtuW" : "bdhmpqtu");
+	    command = menuSelect(COMMAND_LINE_Y, COMMAND_LINE_X, menuMain, 8,
+	        s, MENU_HORIZ | MENU_BUTTON | MENU_ACCEPT_OTHERS, 0);
+	} else {
+	    s = ((opentype == O_RDWR) ? "hpquW" : "hpqu");
+	    command = menuSelect(COMMAND_LINE_Y, COMMAND_LINE_X, menuMain, 8,
+	        s, MENU_HORIZ | MENU_BUTTON | MENU_ACCEPT_OTHERS, 0);
+	}
+	switch ( command ) {
+	case 'B':
+	case 'b':
+	    if (p_info[cur_part].id > 0)
+		p_info[cur_part].flags ^= 0x80;
+	    else
+		print_warning(NO_FLAGS);
+	    break;
+	case 'D':
+	case 'd':
+	    if (p_info[cur_part].id > 0) {
+		del_part(cur_part);
+		if (cur_part >= num_parts)
+		    cur_part = num_parts - 1;
+		draw_screen();
+	    } else
+		print_warning(DEL_EMPTY);
+	    break;
+	case 'G':
+	case 'g':
+	    if (change_geometry())
+		draw_screen();
+	    break;
+	case 'M':
+	case 'm':
+	    if (p_info[cur_part].id > 0) {
+		if (p_info[cur_part].first_sector == 0 ||
+		    IS_LOGICAL(p_info[cur_part].num)) {
+		    if (p_info[cur_part].offset == sectors)
+			p_info[cur_part].offset = 1;
+		    else
+			p_info[cur_part].offset = sectors;
+		    draw_screen();
+		} else if (p_info[cur_part].offset != 0)
+		    p_info[cur_part].offset = 0;
+		else
+		    print_warning(MAX_UNMAXABLE);
+	    } else
+		print_warning(MAX_UNMAXABLE);
+	    break;
+	case 'N':
+	case 'n':
+	    if (p_info[cur_part].id == FREE_SPACE) {
+		new_part(cur_part);
+		draw_screen();
+	    } else if (p_info[cur_part].id == UNUSABLE)
+		print_warning(ADD_UNUSABLE);
+	    else
+		print_warning(ADD_EXISTS);
+	    break;
+	case 'P':
+	case 'p':
+	    print_tables();
+	    draw_screen();
+	    break;
+	case 'Q':
+	case 'q':
+	    done = TRUE;
+	    break;
+	case 'T':
+	case 't':
+	    if (p_info[cur_part].id > 0) {
+		change_id(cur_part);
+		draw_screen();
+	    } else
+		print_warning(TYPE_EMPTY);
+	    break;
+	case 'U':
+	case 'u':
+	    if (display_units == MEGABYTES)
+		display_units = SECTORS;
+	    else if (display_units == SECTORS)
+		display_units = CYLINDERS;
+	    else if (display_units == CYLINDERS)
+		display_units = MEGABYTES;
+	    draw_screen();
+	    break;
+	case 'W':
+	    write_part_table();
+	    break;
+	case 'H':
+	case 'h':
+	case '?':
+	    display_help();
+	    draw_screen();
+	    break;
+	case MENU_UP : /* Up arrow */
+	    if (!draw_cursor(-1))
+		command = 0;
+	    else
+		print_warning(NO_MORE_PARTS);
+	    break;
+	case MENU_DOWN : /* Down arrow */
+	    if (!draw_cursor(1))
+		command = 0;
+	    else
+		print_warning(NO_MORE_PARTS);
+	    break;
+	case REDRAWKEY:
+	    clear();
+	    draw_screen();
+	    break;
+	default:
+	    print_warning(BAD_COMMAND);
+	    putchar(BELL); /* CTRL-G */
+	}
+    }
+
+    die_x(0);
+}
+
+void copyright(void)
+{
+    fprintf(stderr, "Copyright (C) 1994-1997 Kevin E. Martin & aeb\n");
+}
+
+void usage(char *prog_name)
+{
+    fprintf(stderr, "\nUsage:\n");
+    fprintf(stderr, "Print version:\n");
+    fprintf(stderr, "\t%s -v\n", prog_name);
+    fprintf(stderr, "Print partition table:\n");
+    fprintf(stderr, "\t%s -P {r|s|t} [options] device\n", prog_name);
+    fprintf(stderr, "Interactive use:\n");
+    fprintf(stderr, "\t%s [options] device\n", prog_name);
+    fprintf(stderr, "
+Options:
+-a: Use arrow instead of highlighting;
+-z: Start with a zero partition table, instead of reading the pt from disk;
+-c C -h H -s S: Override the kernel's idea of the number of cylinders,
+                the number of heads and the number of sectors/track.\n\n");
+
+    copyright();
+}
+
+int
+main(int argc, char **argv)
+{
+    int c;
+    int i, len;
+
+    setlocale(LC_CTYPE, "");
+
+    while ((c = getopt(argc, argv, "ac:h:s:vzP:")) != EOF)
+	switch (c) {
+	case 'a':
+	    arrow_cursor = TRUE;
+	    break;
+	case 'c':
+	    cylinders = atoi(optarg);
+	    if (cylinders <= 0 || cylinders > MAX_CYLINDERS) {
+		fprintf(stderr, "%s: %s\n", argv[0], BAD_CYLINDERS);
+		exit(1);
+	    }
+	    break;
+	case 'h':
+	    heads = atoi(optarg);
+	    if (heads <= 0 || heads > MAX_HEADS) {
+		fprintf(stderr, "%s: %s\n", argv[0], BAD_HEADS);
+		exit(1);
+	    }
+	    break;
+	case 's':
+	    sectors = atoi(optarg);
+	    if (sectors <= 0 || sectors > MAX_SECTORS) {
+		fprintf(stderr, "%s: %s\n", argv[0], BAD_SECTORS);
+		exit(1);
+	    }
+	    break;
+	case 'v':
+	    fprintf(stderr, "cfdisk %s\n", VERSION);
+	    copyright();
+	    exit(0);
+	case 'z':
+	    zero_table = TRUE;
+	    break;
+	case 'P':
+	    len = strlen(optarg);
+	    for (i = 0; i < len; i++) {
+		switch (optarg[i]) {
+		case 'r':
+		    print_only |= PRINT_RAW_TABLE;
+		    break;
+		case 's':
+		    print_only |= PRINT_SECTOR_TABLE;
+		    break;
+		case 't':
+		    print_only |= PRINT_PARTITION_TABLE;
+		    break;
+		default:
+		    usage(argv[0]);
+		    break;
+		}
+	    }
+	    break;
+	default:
+	    usage(argv[0]);
+	    exit(1);
+	}
+
+    if (argc-optind == 1)
+	disk_device = argv[optind];
+    else if (argc-optind != 0) {
+	usage(argv[0]);
+	exit(1);
+    } else if ((fd = open(DEFAULT_DEVICE, O_RDONLY)) < 0)
+	disk_device = ALTERNATE_DEVICE;
+    else close(fd);
+
+    if (print_only) {
+	fill_p_info();
+	if (print_only & PRINT_RAW_TABLE)
+	    print_raw_table();
+	if (print_only & PRINT_SECTOR_TABLE)
+	    print_p_info();
+	if (print_only & PRINT_PARTITION_TABLE)
+	    print_part_table();
+    } else
+	do_curses_fdisk();
+
+    return 0;
+}