getopt32: add new syntax of 'o:+' and 'o:*' for -o NUM and -o LIST

[oweals/busybox.git] / util-linux / fdisk.c

diff --git a/util-linux/fdisk.c b/util-linux/fdisk.c
index e47406b3c493b74266cd1dd4e1b5fa8c3a8b392d..6391f9bd92dbd558ee5e0e0b077951ba168917f9 100644 (file)
--- a/util-linux/fdisk.c
+++ b/util-linux/fdisk.c
@@ -4,36 +4,98 @@
  * Copyright (C) 1992  A. V. Le Blanc (LeBlanc@mcc.ac.uk)
  * Copyright (C) 2001,2002 Vladimir Oleynik <dzo@simtreas.ru> (initial bb port)
  *
  * Copyright (C) 1992  A. V. Le Blanc (LeBlanc@mcc.ac.uk)
  * Copyright (C) 2001,2002 Vladimir Oleynik <dzo@simtreas.ru> (initial bb port)
  *

- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.

  */
 
  */
 

+/* Looks like someone forgot to add this to config system */
+//usage:#ifndef ENABLE_FEATURE_FDISK_BLKSIZE
+//usage:# define ENABLE_FEATURE_FDISK_BLKSIZE 0
+//usage:# define IF_FEATURE_FDISK_BLKSIZE(a)
+//usage:#endif
+//usage:
+//usage:#define fdisk_trivial_usage
+//usage:       "[-ul" IF_FEATURE_FDISK_BLKSIZE("s") "] "
+//usage:       "[-C CYLINDERS] [-H HEADS] [-S SECTORS] [-b SSZ] DISK"
+//usage:#define fdisk_full_usage "\n\n"
+//usage:       "Change partition table\n"
+//usage:     "\n       -u              Start and End are in sectors (instead of cylinders)"
+//usage:     "\n       -l              Show partition table for each DISK, then exit"
+//usage:       IF_FEATURE_FDISK_BLKSIZE(
+//usage:     "\n       -s              Show partition sizes in kb for each DISK, then exit"
+//usage:       )
+//usage:     "\n       -b 2048         (for certain MO disks) use 2048-byte sectors"
+//usage:     "\n       -C CYLINDERS    Set number of cylinders/heads/sectors"
+//usage:     "\n       -H HEADS"
+//usage:     "\n       -S SECTORS"
+
+#ifndef _LARGEFILE64_SOURCE
+/* For lseek64 */
+# define _LARGEFILE64_SOURCE
+#endif

 #include <assert.h>             /* assert */
 #include <assert.h>             /* assert */

-#include "busybox.h"
-#define _(x) x
+#include <sys/mount.h>
+#if !defined(BLKSSZGET)
+# define BLKSSZGET _IO(0x12, 104)
+#endif
+#if !defined(BLKGETSIZE64)
+# define BLKGETSIZE64 _IOR(0x12,114,size_t)
+#endif
+#include "libbb.h"

 
 

-#define DEFAULT_SECTOR_SIZE     512
-#define MAX_SECTOR_SIZE 2048
-#define SECTOR_SIZE     512     /* still used in osf/sgi/sun code */
-#define MAXIMUM_PARTS   60
+#if BB_LITTLE_ENDIAN
+# define inline_if_little_endian ALWAYS_INLINE
+#else
+# define inline_if_little_endian /* nothing */
+#endif

 
 

-#define ACTIVE_FLAG     0x80

 
 

-#define EXTENDED        0x05
-#define WIN98_EXTENDED  0x0f
-#define LINUX_PARTITION 0x81
-#define LINUX_SWAP      0x82
-#define LINUX_NATIVE    0x83
-#define LINUX_EXTENDED  0x85
-#define LINUX_LVM       0x8e
-#define LINUX_RAID      0xfd
+/* Looks like someone forgot to add this to config system */
+#ifndef ENABLE_FEATURE_FDISK_BLKSIZE
+# define ENABLE_FEATURE_FDISK_BLKSIZE 0
+# define IF_FEATURE_FDISK_BLKSIZE(a)
+#endif

 
 

-#define IS_EXTENDED(i) \
-       ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
+#define DEFAULT_SECTOR_SIZE      512
+#define DEFAULT_SECTOR_SIZE_STR "512"
+#define MAX_SECTOR_SIZE         2048
+#define SECTOR_SIZE              512 /* still used in osf/sgi/sun code */
+#define MAXIMUM_PARTS             60
+
+#define ACTIVE_FLAG             0x80
+
+#define EXTENDED                0x05
+#define WIN98_EXTENDED          0x0f
+#define LINUX_PARTITION         0x81
+#define LINUX_SWAP              0x82
+#define LINUX_NATIVE            0x83
+#define LINUX_EXTENDED          0x85
+#define LINUX_LVM               0x8e
+#define LINUX_RAID              0xfd
+
+
+enum {
+       OPT_b = 1 << 0,
+       OPT_C = 1 << 1,
+       OPT_H = 1 << 2,
+       OPT_l = 1 << 3,
+       OPT_S = 1 << 4,
+       OPT_u = 1 << 5,
+       OPT_s = (1 << 6) * ENABLE_FEATURE_FDISK_BLKSIZE,
+};

 
 

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

 
 

-#define cround(n)       (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
-#define scround(x)      (((x)+units_per_sector-1)/units_per_sector)
+typedef unsigned long long ullong;
+/* Used for sector numbers. Partition formats we know
+ * do not support more than 2^32 sectors
+ */
+typedef uint32_t sector_t;
+#if UINT_MAX == 4294967295
+# define SECT_FMT ""
+#elif ULONG_MAX == 4294967295
+# define SECT_FMT "l"
+#else
+# error Cant detect sizeof(uint32_t)
+#endif

 
 struct hd_geometry {
        unsigned char heads;
 
 struct hd_geometry {
        unsigned char heads;


@@ -44,216 +106,417 @@ struct hd_geometry {
 
 #define HDIO_GETGEO     0x0301  /* get device geometry */
 
 
 #define HDIO_GETGEO     0x0301  /* get device geometry */
 

-struct systypes {
-       const char *name;
-};
-
-static uint sector_size = DEFAULT_SECTOR_SIZE;
-static uint user_set_sector_size;
-static uint sector_offset = 1;
+static const char msg_building_new_label[] ALIGN1 =
+"Building a new %s. Changes will remain in memory only,\n"
+"until you decide to write them. After that the previous content\n"
+"won't be recoverable.\n\n";

 
 

-/*
- * Raw disk label. For DOS-type partition tables the MBR,
- * with descriptions of the primary partitions.
- */
-#if (MAX_SECTOR_SIZE) > (BUFSIZ+1)
-static char MBRbuffer[MAX_SECTOR_SIZE];
-#else
-# define MBRbuffer bb_common_bufsiz1
-#endif
-
-#ifdef CONFIG_FEATURE_OSF_LABEL
-static int possibly_osf_label;
-#endif
-
-static uint heads, sectors, cylinders;
-static void update_units(void);
+static const char msg_part_already_defined[] ALIGN1 =
+"Partition %u is already defined, delete it before re-adding\n";

 
 
 
 

-/*
- * return partition name - uses static storage unless buf is supplied
- */
-static const char *
-partname(const char *dev, int pno, int lth)
-{
-       static char buffer[80];
-       const char *p;
-       int w, wp;
-       int bufsiz;
-       char *bufp;
-
-       bufp = buffer;
-       bufsiz = sizeof(buffer);
-
-       w = strlen(dev);
-       p = "";
-
-       if (isdigit(dev[w-1]))
-               p = "p";
-
-       /* devfs kludge - note: fdisk partition names are not supposed
-          to equal kernel names, so there is no reason to do this */
-       if (strcmp(dev + w - 4, "disc") == 0) {
-               w -= 4;
-               p = "part";
-       }
-
-       wp = strlen(p);
-
-       if (lth) {
-               snprintf(bufp, bufsiz, "%*.*s%s%-2u",
-                        lth-wp-2, w, dev, p, pno);
-       } else {
-               snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
-       }
-       return bufp;
-}
-

 struct partition {
        unsigned char boot_ind;         /* 0x80 - active */
        unsigned char head;             /* starting head */
        unsigned char sector;           /* starting sector */
        unsigned char cyl;              /* starting cylinder */
 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 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 */
        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 */

-} ATTRIBUTE_PACKED;
+} PACKED;

 
 

-enum failure {
-       ioctl_error, unable_to_open, unable_to_read, unable_to_seek,
-       unable_to_write
+/*
+ * per partition table entry data
+ *
+ * The four primary partitions have the same sectorbuffer (MBRbuffer)
+ * and have NULL ext_pointer.
+ * Each logical partition table entry has two pointers, one for the
+ * partition and one link to the next one.
+ */
+struct pte {
+       struct partition *part_table;   /* points into sectorbuffer */
+       struct partition *ext_pointer;  /* points into sectorbuffer */
+       sector_t offset_from_dev_start; /* disk sector number */
+       char *sectorbuffer;             /* disk sector contents */
+#if ENABLE_FEATURE_FDISK_WRITABLE
+       char changed;                   /* boolean */
+#endif

 };
 
 };
 

+#define unable_to_open "can't open '%s'"
+#define unable_to_read "can't read from %s"
+#define unable_to_seek "can't seek on %s"
+

 enum label_type {
 enum label_type {

-       label_dos, label_sun, label_sgi, label_aix, label_osf
+       LABEL_DOS, LABEL_SUN, LABEL_SGI, LABEL_AIX, LABEL_OSF, LABEL_GPT

 };
 };

-#define LABEL_IS_DOS   (label_dos == current_label_type)

 
 

-#ifdef CONFIG_FEATURE_SUN_LABEL
-#define LABEL_IS_SUN   (label_sun == current_label_type)
+#define LABEL_IS_DOS   (LABEL_DOS == current_label_type)
+
+#if ENABLE_FEATURE_SUN_LABEL
+#define LABEL_IS_SUN   (LABEL_SUN == current_label_type)

 #define STATIC_SUN static
 #else
 #define LABEL_IS_SUN   0
 #define STATIC_SUN extern
 #endif
 
 #define STATIC_SUN static
 #else
 #define LABEL_IS_SUN   0
 #define STATIC_SUN extern
 #endif
 

-#ifdef CONFIG_FEATURE_SGI_LABEL
-#define LABEL_IS_SGI   (label_sgi == current_label_type)
+#if ENABLE_FEATURE_SGI_LABEL
+#define LABEL_IS_SGI   (LABEL_SGI == current_label_type)

 #define STATIC_SGI static
 #else
 #define LABEL_IS_SGI   0
 #define STATIC_SGI extern
 #endif
 
 #define STATIC_SGI static
 #else
 #define LABEL_IS_SGI   0
 #define STATIC_SGI extern
 #endif
 

-#ifdef CONFIG_FEATURE_AIX_LABEL
-#define LABEL_IS_AIX   (label_aix == current_label_type)
+#if ENABLE_FEATURE_AIX_LABEL
+#define LABEL_IS_AIX   (LABEL_AIX == current_label_type)

 #define STATIC_AIX static
 #else
 #define LABEL_IS_AIX   0
 #define STATIC_AIX extern
 #endif
 
 #define STATIC_AIX static
 #else
 #define LABEL_IS_AIX   0
 #define STATIC_AIX extern
 #endif
 

-#ifdef CONFIG_FEATURE_OSF_LABEL
-#define LABEL_IS_OSF   (label_osf == current_label_type)
+#if ENABLE_FEATURE_OSF_LABEL
+#define LABEL_IS_OSF   (LABEL_OSF == current_label_type)

 #define STATIC_OSF static
 #else
 #define LABEL_IS_OSF   0
 #define STATIC_OSF extern
 #endif
 
 #define STATIC_OSF static
 #else
 #define LABEL_IS_OSF   0
 #define STATIC_OSF extern
 #endif
 

-enum action { fdisk, require, try_only, create_empty_dos, create_empty_sun };
+#if ENABLE_FEATURE_GPT_LABEL
+#define LABEL_IS_GPT   (LABEL_GPT == current_label_type)
+#define STATIC_GPT static
+#else
+#define LABEL_IS_GPT   0
+#define STATIC_GPT extern
+#endif

 
 

-static enum label_type current_label_type;
+enum action { OPEN_MAIN, TRY_ONLY, CREATE_EMPTY_DOS, CREATE_EMPTY_SUN };

 
 

-static const char *disk_device;
-static int fd;                  /* the disk */
-static int partitions = 4;      /* maximum partition + 1 */
-static uint display_in_cyl_units = 1;
-static uint units_per_sector = 1;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+static void update_units(void);
+#if ENABLE_FEATURE_FDISK_WRITABLE

 static void change_units(void);
 static void reread_partition_table(int leave);
 static void delete_partition(int i);
 static void change_units(void);
 static void reread_partition_table(int leave);
 static void delete_partition(int i);

-static int get_partition(int warn, int max);
-static void list_types(const struct systypes *sys);
-static uint read_int(uint low, uint dflt, uint high, uint base, char *mesg);
+static unsigned get_partition(int warn, unsigned max);
+static void list_types(const char *const *sys);
+static sector_t read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg);

 #endif
 static const char *partition_type(unsigned char type);
 #endif
 static const char *partition_type(unsigned char type);

-static void fdisk_fatal(enum failure why) ATTRIBUTE_NORETURN;

 static void get_geometry(void);
 static void get_geometry(void);

+static void read_pte(struct pte *pe, sector_t offset);
+#if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE

 static int get_boot(enum action what);
 static int get_boot(enum action what);

+#else
+static int get_boot(void);
+#endif

 
 #define PLURAL   0
 #define SINGULAR 1
 
 
 #define PLURAL   0
 #define SINGULAR 1
 

-#define hex_val(c)      ({ \
-                               char _c = (c); \
-                               isdigit(_c) ? _c - '0' : \
-                               tolower(_c) + 10 - 'a'; \
-                       })
-
+static sector_t get_start_sect(const struct partition *p);
+static sector_t get_nr_sects(const struct partition *p);

 
 

-#define LINE_LENGTH     800
-#define pt_offset(b, n) ((struct partition *)((b) + 0x1be + \
-                               (n) * sizeof(struct partition)))
-#define sector(s)       ((s) & 0x3f)
-#define cylinder(s, c)  ((c) | (((s) & 0xc0) << 2))
+/* DOS partition types */

 
 

-#define hsc2sector(h,s,c) (sector(s) - 1 + sectors * \
-                               ((h) + heads * cylinder(s,c)))
-#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;      \
-                       }
+static const char *const i386_sys_types[] = {
+       "\x00" "Empty",
+       "\x01" "FAT12",
+       "\x04" "FAT16 <32M",
+       "\x05" "Extended",         /* DOS 3.3+ extended partition */
+       "\x06" "FAT16",            /* DOS 16-bit >=32M */
+       "\x07" "HPFS/NTFS",        /* OS/2 IFS, eg, HPFS or NTFS or QNX */
+       "\x0a" "OS/2 Boot Manager",/* OS/2 Boot Manager */
+       "\x0b" "Win95 FAT32",
+       "\x0c" "Win95 FAT32 (LBA)",/* LBA really is 'Extended Int 13h' */
+       "\x0e" "Win95 FAT16 (LBA)",
+       "\x0f" "Win95 Ext'd (LBA)",
+       "\x11" "Hidden FAT12",
+       "\x12" "Compaq diagnostics",
+       "\x14" "Hidden FAT16 <32M",
+       "\x16" "Hidden FAT16",
+       "\x17" "Hidden HPFS/NTFS",
+       "\x1b" "Hidden Win95 FAT32",
+       "\x1c" "Hidden W95 FAT32 (LBA)",
+       "\x1e" "Hidden W95 FAT16 (LBA)",
+       "\x3c" "Part.Magic recovery",
+       "\x41" "PPC PReP Boot",
+       "\x42" "SFS",
+       "\x63" "GNU HURD or SysV", /* GNU HURD or Mach or Sys V/386 (such as ISC UNIX) */
+       "\x80" "Old Minix",        /* Minix 1.4a and earlier */
+       "\x81" "Minix / old Linux",/* Minix 1.4b and later */
+       "\x82" "Linux swap",       /* also Solaris */
+       "\x83" "Linux",
+       "\x84" "OS/2 hidden C: drive",
+       "\x85" "Linux extended",
+       "\x86" "NTFS volume set",
+       "\x87" "NTFS volume set",
+       "\x8e" "Linux LVM",
+       "\x9f" "BSD/OS",           /* BSDI */
+       "\xa0" "Thinkpad hibernation",
+       "\xa5" "FreeBSD",          /* various BSD flavours */
+       "\xa6" "OpenBSD",
+       "\xa8" "Darwin UFS",
+       "\xa9" "NetBSD",
+       "\xab" "Darwin boot",
+       "\xb7" "BSDI fs",
+       "\xb8" "BSDI swap",
+       "\xbe" "Solaris boot",
+       "\xeb" "BeOS fs",
+       "\xee" "EFI GPT",                    /* Intel EFI GUID Partition Table */
+       "\xef" "EFI (FAT-12/16/32)",         /* Intel EFI System Partition */
+       "\xf0" "Linux/PA-RISC boot",         /* Linux/PA-RISC boot loader */
+       "\xf2" "DOS secondary",              /* DOS 3.3+ secondary */
+       "\xfd" "Linux raid autodetect",      /* New (2.2.x) raid partition with
+                                               autodetect using persistent
+                                               superblock */
+#if 0 /* ENABLE_WEIRD_PARTITION_TYPES */
+       "\x02" "XENIX root",
+       "\x03" "XENIX usr",
+       "\x08" "AIX",              /* AIX boot (AIX -- PS/2 port) or SplitDrive */
+       "\x09" "AIX bootable",     /* AIX data or Coherent */
+       "\x10" "OPUS",
+       "\x18" "AST SmartSleep",
+       "\x24" "NEC DOS",
+       "\x39" "Plan 9",
+       "\x40" "Venix 80286",
+       "\x4d" "QNX4.x",
+       "\x4e" "QNX4.x 2nd part",
+       "\x4f" "QNX4.x 3rd part",
+       "\x50" "OnTrack DM",
+       "\x51" "OnTrack DM6 Aux1", /* (or Novell) */
+       "\x52" "CP/M",             /* CP/M or Microport SysV/AT */
+       "\x53" "OnTrack DM6 Aux3",
+       "\x54" "OnTrackDM6",
+       "\x55" "EZ-Drive",
+       "\x56" "Golden Bow",
+       "\x5c" "Priam Edisk",
+       "\x61" "SpeedStor",
+       "\x64" "Novell Netware 286",
+       "\x65" "Novell Netware 386",
+       "\x70" "DiskSecure Multi-Boot",
+       "\x75" "PC/IX",
+       "\x93" "Amoeba",
+       "\x94" "Amoeba BBT",       /* (bad block table) */
+       "\xa7" "NeXTSTEP",
+       "\xbb" "Boot Wizard hidden",
+       "\xc1" "DRDOS/sec (FAT-12)",
+       "\xc4" "DRDOS/sec (FAT-16 < 32M)",
+       "\xc6" "DRDOS/sec (FAT-16)",
+       "\xc7" "Syrinx",
+       "\xda" "Non-FS data",
+       "\xdb" "CP/M / CTOS / ...",/* CP/M or Concurrent CP/M or
+                                     Concurrent DOS or CTOS */
+       "\xde" "Dell Utility",     /* Dell PowerEdge Server utilities */
+       "\xdf" "BootIt",           /* BootIt EMBRM */
+       "\xe1" "DOS access",       /* DOS access or SpeedStor 12-bit FAT
+                                     extended partition */
+       "\xe3" "DOS R/O",          /* DOS R/O or SpeedStor */
+       "\xe4" "SpeedStor",        /* SpeedStor 16-bit FAT extended
+                                     partition < 1024 cyl. */
+       "\xf1" "SpeedStor",
+       "\xf4" "SpeedStor",        /* SpeedStor large partition */
+       "\xfe" "LANstep",          /* SpeedStor >1024 cyl. or LANstep */
+       "\xff" "BBT",              /* Xenix Bad Block Table */
+#endif
+       NULL
+};

 
 

+enum {
+       dev_fd = 3                  /* the disk */
+};

 
 

-static int32_t get_start_sect(const struct partition *p);
-static int32_t get_nr_sects(const struct partition *p);
+/* Globals */
+struct globals {
+       char *line_ptr;
+
+       const char *disk_device;
+       int g_partitions; // = 4;       /* maximum partition + 1 */
+       unsigned units_per_sector; // = 1;
+       unsigned sector_size; // = DEFAULT_SECTOR_SIZE;
+       unsigned user_set_sector_size;
+       unsigned sector_offset; // = 1;
+       unsigned g_heads, g_sectors, g_cylinders;
+       smallint /* enum label_type */ current_label_type;
+       smallint display_in_cyl_units; // = 1;
+#if ENABLE_FEATURE_OSF_LABEL
+       smallint possibly_osf_label;
+#endif

 
 

-/*
- * per partition table entry data
- *
- * The four primary partitions have the same sectorbuffer (MBRbuffer)
- * and have NULL ext_pointer.
- * Each logical partition table entry has two pointers, one for the
- * partition and one link to the next one.
- */
-static struct pte {
-       struct partition *part_table;   /* points into sectorbuffer */
-       struct partition *ext_pointer;  /* points into sectorbuffer */
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-       char changed;           /* boolean */
+       smallint listing;               /* no aborts for fdisk -l */
+       smallint dos_compatible_flag; // = 1;
+#if ENABLE_FEATURE_FDISK_WRITABLE
+       //int dos_changed;
+       smallint nowarn;                /* no warnings for fdisk -l/-s */

 #endif
 #endif

-       off_t offset;            /* disk sector number */
-       char *sectorbuffer;     /* disk sector contents */
-} ptes[MAXIMUM_PARTS];
+       int ext_index;                  /* the prime extended partition */
+       unsigned user_cylinders, user_heads, user_sectors;
+       unsigned pt_heads, pt_sectors;
+       unsigned kern_heads, kern_sectors;
+       sector_t extended_offset;       /* offset of link pointers */
+       sector_t total_number_of_sectors;
+
+       jmp_buf listingbuf;
+       char line_buffer[80];
+       char partname_buffer[80];
+       /* Raw disk label. For DOS-type partition tables the MBR,
+        * with descriptions of the primary partitions. */
+       char MBRbuffer[MAX_SECTOR_SIZE];
+       /* Partition tables */
+       struct pte ptes[MAXIMUM_PARTS];
+};
+#define G (*ptr_to_globals)
+#define line_ptr             (G.line_ptr            )
+#define disk_device          (G.disk_device         )
+#define g_partitions         (G.g_partitions        )
+#define units_per_sector     (G.units_per_sector    )
+#define sector_size          (G.sector_size         )
+#define user_set_sector_size (G.user_set_sector_size)
+#define sector_offset        (G.sector_offset       )
+#define g_heads              (G.g_heads             )
+#define g_sectors            (G.g_sectors           )
+#define g_cylinders          (G.g_cylinders         )
+#define current_label_type   (G.current_label_type  )
+#define display_in_cyl_units (G.display_in_cyl_units)
+#define possibly_osf_label   (G.possibly_osf_label  )
+#define listing                 (G.listing                )
+#define dos_compatible_flag     (G.dos_compatible_flag    )
+#define nowarn                  (G.nowarn                 )
+#define ext_index               (G.ext_index              )
+#define user_cylinders          (G.user_cylinders         )
+#define user_heads              (G.user_heads             )
+#define user_sectors            (G.user_sectors           )
+#define pt_heads                (G.pt_heads               )
+#define pt_sectors              (G.pt_sectors             )
+#define kern_heads              (G.kern_heads             )
+#define kern_sectors            (G.kern_sectors           )
+#define extended_offset         (G.extended_offset        )
+#define total_number_of_sectors (G.total_number_of_sectors)
+#define listingbuf      (G.listingbuf     )
+#define line_buffer     (G.line_buffer    )
+#define partname_buffer (G.partname_buffer)
+#define MBRbuffer       (G.MBRbuffer      )
+#define ptes            (G.ptes           )
+#define INIT_G() do { \
+       SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+       sector_size = DEFAULT_SECTOR_SIZE; \
+       sector_offset = 1; \
+       g_partitions = 4; \
+       display_in_cyl_units = 1; \
+       units_per_sector = 1; \
+       dos_compatible_flag = 1; \
+} while (0)
+
+
+/* TODO: move to libbb? */
+/* TODO: return unsigned long long, FEATURE_FDISK_BLKSIZE _can_ handle
+ * disks > 2^32 sectors
+ */
+static sector_t bb_BLKGETSIZE_sectors(int fd)
+{
+       uint64_t v64;
+       unsigned long longsectors;
+
+       if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
+               /* Got bytes, convert to 512 byte sectors */
+               v64 >>= 9;
+               if (v64 != (sector_t)v64) {
+ ret_trunc:
+                       /* Not only DOS, but all other partition tables
+                        * we support can't record more than 32 bit
+                        * sector counts or offsets
+                        */
+                       bb_error_msg("device has more than 2^32 sectors, can't use all of them");
+                       v64 = (uint32_t)-1L;
+               }
+               return v64;
+       }
+       /* Needs temp of type long */
+       if (ioctl(fd, BLKGETSIZE, &longsectors)) {
+               /* Perhaps this is a disk image */
+               off_t sz = lseek(fd, 0, SEEK_END);
+               longsectors = 0;
+               if (sz > 0)
+                       longsectors = (uoff_t)sz / sector_size;
+               lseek(fd, 0, SEEK_SET);
+       }
+       if (sizeof(long) > sizeof(sector_t)
+        && longsectors != (sector_t)longsectors
+       ) {
+               goto ret_trunc;
+       }
+       return longsectors;
+}
+

 
 

+#define IS_EXTENDED(i) \
+       ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
+
+#define cround(n)       (display_in_cyl_units ? ((n)/units_per_sector)+1 : (n))
+
+#define scround(x)      (((x)+units_per_sector-1)/units_per_sector)
+
+#define pt_offset(b, n) \
+       ((struct partition *)((b) + 0x1be + (n) * sizeof(struct partition)))
+
+#define sector(s)       ((s) & 0x3f)
+
+#define cylinder(s, c)  ((c) | (((s) & 0xc0) << 2))
+
+#define hsc2sector(h,s,c) \
+       (sector(s) - 1 + sectors * ((h) + heads * cylinder(s,c)))

 
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE

 static void
 static void

-set_all_unchanged(void)
+close_dev_fd(void)

 {
 {

-       int i;
-
-       for (i = 0; i < MAXIMUM_PARTS; i++)
-               ptes[i].changed = 0;
+       /* Not really closing, but making sure it is open, and to harmless place */
+       xmove_fd(xopen(bb_dev_null, O_RDONLY), dev_fd);

 }
 
 }
 

-static void
-set_changed(int i)
+/*
+ * Return partition name - uses static storage
+ */
+static const char *
+partname(const char *dev, int pno, int lth)

 {
 {

-       ptes[i].changed = 1;
+       const char *p;
+       int w, wp;
+       int bufsiz;
+       char *bufp;
+
+       bufp = partname_buffer;
+       bufsiz = sizeof(partname_buffer);
+
+       w = strlen(dev);
+       p = "";
+
+       if (isdigit(dev[w-1]))
+               p = "p";
+
+       /* devfs kludge - note: fdisk partition names are not supposed
+          to equal kernel names, so there is no reason to do this */
+       if (strcmp(dev + w - 4, "disc") == 0) {
+               w -= 4;
+               p = "part";
+       }
+
+       wp = strlen(p);
+
+       if (lth) {
+               snprintf(bufp, bufsiz, "%*.*s%s%-2u",
+                       lth-wp-2, w, dev, p, pno);
+       } else {
+               snprintf(bufp, bufsiz, "%.*s%s%-2u", w, dev, p, pno);
+       }
+       return bufp;

 }
 }

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */

 
 

-static inline struct partition *
+static ALWAYS_INLINE struct partition *

 get_part_table(int i)
 {
        return ptes[i].part_table;
 get_part_table(int i)
 {
        return ptes[i].part_table;


@@ -263,75 +526,131 @@ static const char *
 str_units(int n)
 {      /* n==1: use singular */
        if (n == 1)
 str_units(int n)
 {      /* n==1: use singular */
        if (n == 1)

-               return display_in_cyl_units ? _("cylinder") : _("sector");
-       else
-               return display_in_cyl_units ? _("cylinders") : _("sectors");
+               return display_in_cyl_units ? "cylinder" : "sector";
+       return display_in_cyl_units ? "cylinders" : "sectors";

 }
 
 static int
 valid_part_table_flag(const char *mbuffer)
 {
 }
 
 static int
 valid_part_table_flag(const char *mbuffer)
 {

-       const unsigned char *b = (const unsigned char *)mbuffer;
-       return (b[510] == 0x55 && b[511] == 0xaa);
+       return (mbuffer[510] == 0x55 && (uint8_t)mbuffer[511] == 0xaa);
+}
+
+static void fdisk_fatal(const char *why)
+{
+       if (listing) {
+               close_dev_fd();
+               longjmp(listingbuf, 1);
+       }
+       bb_error_msg_and_die(why, disk_device);

 }
 
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static char line_buffer[LINE_LENGTH];
-static char *line_ptr;
+static void
+seek_sector(sector_t secno)
+{
+#if ENABLE_FDISK_SUPPORT_LARGE_DISKS
+       off64_t off = (off64_t)secno * sector_size;
+       if (lseek64(dev_fd, off, SEEK_SET) == (off64_t) -1)
+               fdisk_fatal(unable_to_seek);
+#else
+       uint64_t off = (uint64_t)secno * sector_size;
+       if (off > MAXINT(off_t)
+        || lseek(dev_fd, (off_t)off, SEEK_SET) == (off_t) -1
+       ) {
+               fdisk_fatal(unable_to_seek);
+       }
+#endif
+}

 
 

-/* read line; return 0 or first char */
+#if ENABLE_FEATURE_FDISK_WRITABLE
+/* Read line; return 0 or first printable char */

 static int
 static int

-read_line(void)
+read_line(const char *prompt)

 {
 {

-       fflush(stdout);         /* requested by niles@scyld.com */
+       int sz;
+
+       sz = read_line_input(NULL, prompt, line_buffer, sizeof(line_buffer), /*timeout*/ -1);
+       if (sz <= 0)
+               exit(EXIT_SUCCESS); /* Ctrl-D or Ctrl-C */
+
+       if (line_buffer[sz-1] == '\n')
+               line_buffer[--sz] = '\0';
+

        line_ptr = line_buffer;
        line_ptr = line_buffer;

-       if (!fgets(line_buffer, LINE_LENGTH, stdin)) {
-               /* error or eof */
-               bb_error_msg_and_die("\ngot EOF, exiting");
-       }
-       while (*line_ptr && !isgraph(*line_ptr))
+       while (*line_ptr != '\0' && (unsigned char)*line_ptr <= ' ')

                line_ptr++;
        return *line_ptr;
 }
 
                line_ptr++;
        return *line_ptr;
 }
 

+static void
+set_all_unchanged(void)
+{
+       int i;
+
+       for (i = 0; i < MAXIMUM_PARTS; i++)
+               ptes[i].changed = 0;
+}
+
+static ALWAYS_INLINE void
+set_changed(int i)
+{
+       ptes[i].changed = 1;
+}
+
+static ALWAYS_INLINE void
+write_part_table_flag(char *b)
+{
+       b[510] = 0x55;
+       b[511] = 0xaa;
+}
+

 static char
 read_nonempty(const char *mesg)
 {
 static char
 read_nonempty(const char *mesg)
 {

-       do {
-               fputs(mesg, stdout);
-       } while (!read_line());
+       while (!read_line(mesg))
+               continue;

        return *line_ptr;
 }
 
 static char
 read_maybe_empty(const char *mesg)
 {
        return *line_ptr;
 }
 
 static char
 read_maybe_empty(const char *mesg)
 {

-       fputs(mesg, stdout);
-       if (!read_line()) {
+       if (!read_line(mesg)) {

                line_ptr = line_buffer;
                line_ptr = line_buffer;

-               *line_ptr = '\n';
-               line_ptr[1] = 0;
+               line_ptr[0] = '\n';
+               line_ptr[1] = '\0';

        }
        }

-       return *line_ptr;
+       return line_ptr[0];

 }
 
 static int
 }
 
 static int

-read_hex(const struct systypes *sys)
+read_hex(const char *const *sys)

 {
 {

+       unsigned long v;

        while (1) {
        while (1) {

-               read_nonempty(_("Hex code (type L to list codes): "));
-               if (*line_ptr == 'l' || *line_ptr == 'L')
+               read_nonempty("Hex code (type L to list codes): ");
+               if ((line_ptr[0] | 0x20) == 'l') {

                        list_types(sys);
                        list_types(sys);

-               else if (isxdigit(*line_ptr)) {
-                       return strtoul(line_ptr, NULL, 16);
+                       continue;

                }
                }

+               v = bb_strtoul(line_ptr, NULL, 16);
+               if (v <= 0xff)
+                       return v;

        }
 }
        }
 }

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+
+static void
+write_sector(sector_t secno, const void *buf)
+{
+       seek_sector(secno);
+       xwrite(dev_fd, buf, sector_size);
+}
+#endif /* FEATURE_FDISK_WRITABLE */
+

 
 #include "fdisk_aix.c"
 
 
 #include "fdisk_aix.c"
 

-typedef struct {
+struct sun_partition {

        unsigned char info[128];   /* Informative text string */
        unsigned char spare0[14];
        struct sun_info {
        unsigned char info[128];   /* Informative text string */
        unsigned char spare0[14];
        struct sun_info {


@@ -357,51 +676,42 @@ typedef struct {
        } partitions[8];
        unsigned short magic;      /* Magic number */
        unsigned short csum;       /* Label xor'd checksum */
        } partitions[8];
        unsigned short magic;      /* Magic number */
        unsigned short csum;       /* Label xor'd checksum */

-} sun_partition;
+} FIX_ALIASING;
+typedef struct sun_partition sun_partition;

 #define sunlabel ((sun_partition *)MBRbuffer)
 #define sunlabel ((sun_partition *)MBRbuffer)

-#define SUNOS_SWAP 3
-#define SUN_WHOLE_DISK 5

 STATIC_OSF void bsd_select(void);
 STATIC_OSF void xbsd_print_disklabel(int);
 #include "fdisk_osf.c"
 
 STATIC_OSF void bsd_select(void);
 STATIC_OSF void xbsd_print_disklabel(int);
 #include "fdisk_osf.c"
 

-#define SGI_VOLHDR      0x00
-/* 1 and 2 were used for drive types no longer supported by SGI */
-#define SGI_SWAP        0x03
-/* 4 and 5 were for filesystem types SGI haven't ever supported on MIPS CPUs */
-#define SGI_VOLUME      0x06
-#define SGI_EFS         0x07
-#define SGI_LVOL        0x08
-#define SGI_RLVOL       0x09
-#define SGI_XFS         0x0a
-#define SGI_XFSLOG      0x0b
-#define SGI_XLV         0x0c
-#define SGI_XVM         0x0d
-#define SGI_ENTIRE_DISK SGI_VOLUME
-#if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL)
-static unsigned short
-__swap16(unsigned short x)
-{
-       return (((uint16_t)(x) & 0xFF) << 8) | (((uint16_t)(x) & 0xFF00) >> 8);
+STATIC_GPT void gpt_list_table(int xtra);
+#include "fdisk_gpt.c"
+
+#if ENABLE_FEATURE_SGI_LABEL || ENABLE_FEATURE_SUN_LABEL
+static uint16_t
+fdisk_swap16(uint16_t x)
+{
+       return (x << 8) | (x >> 8);

 }
 
 static uint32_t
 }
 
 static uint32_t

-__swap32(uint32_t x)
+fdisk_swap32(uint32_t x)

 {
 {

-       return (((x & 0xFF) << 24) |
-               ((x & 0xFF00) << 8) |
-               ((x & 0xFF0000) >> 8) |
-               ((x & 0xFF000000) >> 24));
+       return (x << 24) |
+              ((x & 0xFF00) << 8) |
+              ((x & 0xFF0000) >> 8) |
+              (x >> 24);

 }
 #endif
 
 }
 #endif
 

-STATIC_SGI const struct systypes sgi_sys_types[];
-STATIC_SGI unsigned int sgi_get_num_sectors(int i);
+STATIC_SGI const char *const sgi_sys_types[];
+STATIC_SGI unsigned sgi_get_num_sectors(int i);

 STATIC_SGI int sgi_get_sysid(int i);
 STATIC_SGI void sgi_delete_partition(int i);
 STATIC_SGI void sgi_change_sysid(int i, int sys);
 STATIC_SGI void sgi_list_table(int xtra);
 STATIC_SGI int sgi_get_sysid(int i);
 STATIC_SGI void sgi_delete_partition(int i);
 STATIC_SGI void sgi_change_sysid(int i, int sys);
 STATIC_SGI void sgi_list_table(int xtra);

+#if ENABLE_FEATURE_FDISK_ADVANCED

 STATIC_SGI void sgi_set_xcyl(void);
 STATIC_SGI void sgi_set_xcyl(void);

+#endif

 STATIC_SGI int verify_sgi(int verbose);
 STATIC_SGI void sgi_add_partition(int n, int sys);
 STATIC_SGI void sgi_set_swappartition(int i);
 STATIC_SGI int verify_sgi(int verbose);
 STATIC_SGI void sgi_add_partition(int n, int sys);
 STATIC_SGI void sgi_set_swappartition(int i);


@@ -410,298 +720,100 @@ STATIC_SGI void sgi_set_bootfile(const char* aFile);
 STATIC_SGI void create_sgiinfo(void);
 STATIC_SGI void sgi_write_table(void);
 STATIC_SGI void sgi_set_bootpartition(int i);
 STATIC_SGI void create_sgiinfo(void);
 STATIC_SGI void sgi_write_table(void);
 STATIC_SGI void sgi_set_bootpartition(int i);

-

 #include "fdisk_sgi.c"
 
 #include "fdisk_sgi.c"
 

-STATIC_SUN const struct systypes sun_sys_types[];
+STATIC_SUN const char *const sun_sys_types[];

 STATIC_SUN void sun_delete_partition(int i);
 STATIC_SUN void sun_change_sysid(int i, int sys);
 STATIC_SUN void sun_list_table(int xtra);
 STATIC_SUN void sun_delete_partition(int i);
 STATIC_SUN void sun_change_sysid(int i, int sys);
 STATIC_SUN void sun_list_table(int xtra);

-STATIC_SUN void sun_set_xcyl(void);

 STATIC_SUN void add_sun_partition(int n, int sys);
 STATIC_SUN void add_sun_partition(int n, int sys);

+#if ENABLE_FEATURE_FDISK_ADVANCED

 STATIC_SUN void sun_set_alt_cyl(void);
 STATIC_SUN void sun_set_ncyl(int cyl);
 STATIC_SUN void sun_set_xcyl(void);
 STATIC_SUN void sun_set_ilfact(void);
 STATIC_SUN void sun_set_rspeed(void);
 STATIC_SUN void sun_set_pcylcount(void);
 STATIC_SUN void sun_set_alt_cyl(void);
 STATIC_SUN void sun_set_ncyl(int cyl);
 STATIC_SUN void sun_set_xcyl(void);
 STATIC_SUN void sun_set_ilfact(void);
 STATIC_SUN void sun_set_rspeed(void);
 STATIC_SUN void sun_set_pcylcount(void);

+#endif

 STATIC_SUN void toggle_sunflags(int i, unsigned char mask);
 STATIC_SUN void verify_sun(void);
 STATIC_SUN void sun_write_table(void);
 #include "fdisk_sun.c"
 
 STATIC_SUN void toggle_sunflags(int i, unsigned char mask);
 STATIC_SUN void verify_sun(void);
 STATIC_SUN void sun_write_table(void);
 #include "fdisk_sun.c"
 

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

 
 

-/* A valid partition table sector ends in 0x55 0xaa */
-static unsigned int
-part_table_flag(const char *b)
-{
-       return ((uint) b[510]) + (((uint) b[511]) << 8);
-}
-
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static void
-write_part_table_flag(char *b)
-{
-       b[510] = 0x55;
-       b[511] = 0xaa;
-}
-
-/* start_sect and nr_sects are stored little endian on all machines */
-/* moreover, they are not aligned correctly */
-static 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);
-}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-
-static unsigned int
+static inline_if_little_endian unsigned

 read4_little_endian(const unsigned char *cp)
 {
 read4_little_endian(const unsigned char *cp)
 {

-       return (uint)(cp[0]) + ((uint)(cp[1]) << 8)
-               + ((uint)(cp[2]) << 16) + ((uint)(cp[3]) << 24);
-}
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static void
-set_start_sect(struct partition *p, unsigned int start_sect)
-{
-       store4_little_endian(p->start4, start_sect);
+       uint32_t v;
+       move_from_unaligned32(v, cp);
+       return SWAP_LE32(v);

 }
 }

-#endif

 
 

-static int32_t
+static sector_t

 get_start_sect(const struct partition *p)
 {
        return read4_little_endian(p->start4);
 }
 
 get_start_sect(const struct partition *p)
 {
        return read4_little_endian(p->start4);
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static void
-set_nr_sects(struct partition *p, int32_t nr_sects)
-{
-       store4_little_endian(p->size4, nr_sects);
-}
-#endif
-
-static int32_t
+static sector_t

 get_nr_sects(const struct partition *p)
 {
        return read4_little_endian(p->size4);
 }
 
 get_nr_sects(const struct partition *p)
 {
        return read4_little_endian(p->size4);
 }
 

-/* normally O_RDWR, -l option gives O_RDONLY */
-static int type_open = O_RDWR;
-
-
-static int ext_index;               /* the prime extended partition */
-static int listing;                    /* no aborts for fdisk -l */
-static int dos_compatible_flag = ~0;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static int dos_changed;
-static int nowarn;            /* no warnings for fdisk -l/-s */
-#endif
-
-
-
-static uint user_cylinders, user_heads, user_sectors;
-static uint pt_heads, pt_sectors;
-static uint kern_heads, kern_sectors;
-
-static off_t extended_offset;            /* offset of link pointers */
-
-static unsigned long long total_number_of_sectors;
-
-
-static jmp_buf listingbuf;
-
-static void fdisk_fatal(enum failure why)
+#if ENABLE_FEATURE_FDISK_WRITABLE
+/* start_sect and nr_sects are stored little endian on all machines */
+/* moreover, they are not aligned correctly */
+static inline_if_little_endian void
+store4_little_endian(unsigned char *cp, unsigned val)

 {
 {

-       const char *message;
-
-       if (listing) {
-               close(fd);
-               longjmp(listingbuf, 1);
-       }
-
-       switch (why) {
-       case unable_to_open:
-               message = "\nUnable to open %s";
-               break;
-       case unable_to_read:
-               message = "\nUnable to read %s";
-               break;
-       case unable_to_seek:
-               message = "\nUnable to seek on %s";
-               break;
-       case unable_to_write:
-               message = "\nUnable to write %s";
-               break;
-       case ioctl_error:
-               message = "\nBLKGETSIZE ioctl failed on %s";
-               break;
-       default:
-               message = "\nFatal error";
-       }
-
-       bb_error_msg_and_die(message, disk_device);
+       uint32_t v = SWAP_LE32(val);
+       move_to_unaligned32(cp, v);

 }
 
 static void
 }
 
 static void

-seek_sector(off_t secno)
+set_start_sect(struct partition *p, unsigned start_sect)

 {
 {

-       off_t offset = secno * sector_size;
-       if (lseek(fd, offset, SEEK_SET) == (off_t) -1)
-               fdisk_fatal(unable_to_seek);
+       store4_little_endian(p->start4, start_sect);

 }
 
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE

 static void
 static void

-write_sector(off_t secno, char *buf)
+set_nr_sects(struct partition *p, unsigned nr_sects)

 {
 {

-       seek_sector(secno);
-       if (write(fd, buf, sector_size) != sector_size)
-               fdisk_fatal(unable_to_write);
+       store4_little_endian(p->size4, nr_sects);

 }
 #endif
 
 /* Allocate a buffer and read a partition table sector */
 static void
 }
 #endif
 
 /* Allocate a buffer and read a partition table sector */
 static void

-read_pte(struct pte *pe, off_t offset)
+read_pte(struct pte *pe, sector_t offset)

 {
 {

-       pe->offset = offset;
-       pe->sectorbuffer = (char *) xmalloc(sector_size);
+       pe->offset_from_dev_start = offset;
+       pe->sectorbuffer = xzalloc(sector_size);

        seek_sector(offset);
        seek_sector(offset);

-       if (read(fd, pe->sectorbuffer, sector_size) != sector_size)
+       /* xread would make us abort - bad for fdisk -l */
+       if (full_read(dev_fd, pe->sectorbuffer, sector_size) != sector_size)

                fdisk_fatal(unable_to_read);
                fdisk_fatal(unable_to_read);

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

        pe->changed = 0;
 #endif
        pe->part_table = pe->ext_pointer = NULL;
 }
 
        pe->changed = 0;
 #endif
        pe->part_table = pe->ext_pointer = NULL;
 }
 

-static unsigned int
-get_partition_start(const struct pte *pe)
+static sector_t
+get_partition_start_from_dev_start(const struct pte *pe)

 {
 {

-       return pe->offset + get_start_sect(pe->part_table);
+       return pe->offset_from_dev_start + get_start_sect(pe->part_table);

 }
 
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

 /*
  * Avoid warning about DOS partitions when no DOS partition was changed.
  * Here a heuristic "is probably dos partition".
  * We might also do the opposite and warn in all cases except
  * for "is probably nondos partition".
  */
 /*
  * Avoid warning about DOS partitions when no DOS partition was changed.
  * Here a heuristic "is probably dos partition".
  * We might also do the opposite and warn in all cases except
  * for "is probably nondos partition".
  */

+#ifdef UNUSED

 static int
 is_dos_partition(int t)
 {
 static int
 is_dos_partition(int t)
 {


@@ -711,158 +823,145 @@ is_dos_partition(int t)
                t == 0x1b || t == 0x1c || t == 0x1e || t == 0x24 ||
                t == 0xc1 || t == 0xc4 || t == 0xc6);
 }
                t == 0x1b || t == 0x1c || t == 0x1e || t == 0x24 ||
                t == 0xc1 || t == 0xc4 || t == 0xc6);
 }

+#endif

 
 static void
 menu(void)
 {
 
 static void
 menu(void)
 {

+       puts("Command Action");

        if (LABEL_IS_SUN) {
        if (LABEL_IS_SUN) {

-               puts(_("Command action"));
-               puts(_("\ta\ttoggle a read only flag"));           /* sun */
-               puts(_("\tb\tedit bsd disklabel"));
-               puts(_("\tc\ttoggle the mountable flag"));         /* sun */
-               puts(_("\td\tdelete a partition"));
-               puts(_("\tl\tlist known partition types"));
-               puts(_("\tm\tprint this menu"));
-               puts(_("\tn\tadd a new partition"));
-               puts(_("\to\tcreate a new empty DOS partition table"));
-               puts(_("\tp\tprint the partition table"));
-               puts(_("\tq\tquit without saving changes"));
-               puts(_("\ts\tcreate a new empty Sun disklabel"));  /* sun */
-               puts(_("\tt\tchange a partition's system id"));
-               puts(_("\tu\tchange display/entry units"));
-               puts(_("\tv\tverify the partition table"));
-               puts(_("\tw\twrite table to disk and exit"));
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
-               puts(_("\tx\textra functionality (experts only)"));
+               puts("a\ttoggle a read only flag");           /* sun */
+               puts("b\tedit bsd disklabel");
+               puts("c\ttoggle the mountable flag");         /* sun */
+               puts("d\tdelete a partition");
+               puts("l\tlist known partition types");
+               puts("n\tadd a new partition");
+               puts("o\tcreate a new empty DOS partition table");
+               puts("p\tprint the partition table");
+               puts("q\tquit without saving changes");
+               puts("s\tcreate a new empty Sun disklabel");  /* sun */
+               puts("t\tchange a partition's system id");
+               puts("u\tchange display/entry units");
+               puts("v\tverify the partition table");
+               puts("w\twrite table to disk and exit");
+#if ENABLE_FEATURE_FDISK_ADVANCED
+               puts("x\textra functionality (experts only)");

 #endif
 #endif

-       } else
-       if (LABEL_IS_SGI) {
-               puts(_("Command action"));
-               puts(_("\ta\tselect bootable partition"));    /* sgi flavour */
-               puts(_("\tb\tedit bootfile entry"));          /* sgi */
-               puts(_("\tc\tselect sgi swap partition"));    /* sgi flavour */
-               puts(_("\td\tdelete a partition"));
-               puts(_("\tl\tlist known partition types"));
-               puts(_("\tm\tprint this menu"));
-               puts(_("\tn\tadd a new partition"));
-               puts(_("\to\tcreate a new empty DOS partition table"));
-               puts(_("\tp\tprint the partition table"));
-               puts(_("\tq\tquit without saving changes"));
-               puts(_("\ts\tcreate a new empty Sun disklabel"));  /* sun */
-               puts(_("\tt\tchange a partition's system id"));
-               puts(_("\tu\tchange display/entry units"));
-               puts(_("\tv\tverify the partition table"));
-               puts(_("\tw\twrite table to disk and exit"));
-       } else
-       if (LABEL_IS_AIX) {
-               puts(_("Command action"));
-               puts(_("\tm\tprint this menu"));
-               puts(_("\to\tcreate a new empty DOS partition table"));
-               puts(_("\tq\tquit without saving changes"));
-               puts(_("\ts\tcreate a new empty Sun disklabel"));  /* sun */
-       } else
-       {
-               puts(_("Command action"));
-               puts(_("\ta\ttoggle a bootable flag"));
-               puts(_("\tb\tedit bsd disklabel"));
-               puts(_("\tc\ttoggle the dos compatibility flag"));
-               puts(_("\td\tdelete a partition"));
-               puts(_("\tl\tlist known partition types"));
-               puts(_("\tm\tprint this menu"));
-               puts(_("\tn\tadd a new partition"));
-               puts(_("\to\tcreate a new empty DOS partition table"));
-               puts(_("\tp\tprint the partition table"));
-               puts(_("\tq\tquit without saving changes"));
-               puts(_("\ts\tcreate a new empty Sun disklabel"));  /* sun */
-               puts(_("\tt\tchange a partition's system id"));
-               puts(_("\tu\tchange display/entry units"));
-               puts(_("\tv\tverify the partition table"));
-               puts(_("\tw\twrite table to disk and exit"));
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
-               puts(_("\tx\textra functionality (experts only)"));
+       } else if (LABEL_IS_SGI) {
+               puts("a\tselect bootable partition");    /* sgi flavour */
+               puts("b\tedit bootfile entry");          /* sgi */
+               puts("c\tselect sgi swap partition");    /* sgi flavour */
+               puts("d\tdelete a partition");
+               puts("l\tlist known partition types");
+               puts("n\tadd a new partition");
+               puts("o\tcreate a new empty DOS partition table");
+               puts("p\tprint the partition table");
+               puts("q\tquit without saving changes");
+               puts("s\tcreate a new empty Sun disklabel");  /* sun */
+               puts("t\tchange a partition's system id");
+               puts("u\tchange display/entry units");
+               puts("v\tverify the partition table");
+               puts("w\twrite table to disk and exit");
+       } else if (LABEL_IS_AIX) {
+               puts("o\tcreate a new empty DOS partition table");
+               puts("q\tquit without saving changes");
+               puts("s\tcreate a new empty Sun disklabel");  /* sun */
+       } else if (LABEL_IS_GPT) {
+               puts("o\tcreate a new empty DOS partition table");
+               puts("p\tprint the partition table");
+               puts("q\tquit without saving changes");
+               puts("s\tcreate a new empty Sun disklabel");  /* sun */
+       } else {
+               puts("a\ttoggle a bootable flag");
+               puts("b\tedit bsd disklabel");
+               puts("c\ttoggle the dos compatibility flag");
+               puts("d\tdelete a partition");
+               puts("l\tlist known partition types");
+               puts("n\tadd a new partition");
+               puts("o\tcreate a new empty DOS partition table");
+               puts("p\tprint the partition table");
+               puts("q\tquit without saving changes");
+               puts("s\tcreate a new empty Sun disklabel");  /* sun */
+               puts("t\tchange a partition's system id");
+               puts("u\tchange display/entry units");
+               puts("v\tverify the partition table");
+               puts("w\twrite table to disk and exit");
+#if ENABLE_FEATURE_FDISK_ADVANCED
+               puts("x\textra functionality (experts only)");

 #endif
        }
 }
 #endif
        }
 }

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */

 
 
 
 

-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED

 static void
 xmenu(void)
 {
 static void
 xmenu(void)
 {

+       puts("Command Action");

        if (LABEL_IS_SUN) {
        if (LABEL_IS_SUN) {

-               puts(_("Command action"));
-               puts(_("\ta\tchange number of alternate cylinders"));      /*sun*/
-               puts(_("\tc\tchange number of cylinders"));
-               puts(_("\td\tprint the raw data in the partition table"));
-               puts(_("\te\tchange number of extra sectors per cylinder"));/*sun*/
-               puts(_("\th\tchange number of heads"));
-               puts(_("\ti\tchange interleave factor"));                  /*sun*/
-               puts(_("\to\tchange rotation speed (rpm)"));               /*sun*/
-               puts(_("\tm\tprint this menu"));
-               puts(_("\tp\tprint the partition table"));
-               puts(_("\tq\tquit without saving changes"));
-               puts(_("\tr\treturn to main menu"));
-               puts(_("\ts\tchange number of sectors/track"));
-               puts(_("\tv\tverify the partition table"));
-               puts(_("\tw\twrite table to disk and exit"));
-               puts(_("\ty\tchange number of physical cylinders"));       /*sun*/
-       }  else
-       if (LABEL_IS_SGI) {
-               puts(_("Command action"));
-               puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
-               puts(_("\tc\tchange number of cylinders"));
-               puts(_("\td\tprint the raw data in the partition table"));
-               puts(_("\te\tlist extended partitions"));          /* !sun */
-               puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
-               puts(_("\th\tchange number of heads"));
-               puts(_("\tm\tprint this menu"));
-               puts(_("\tp\tprint the partition table"));
-               puts(_("\tq\tquit without saving changes"));
-               puts(_("\tr\treturn to main menu"));
-               puts(_("\ts\tchange number of sectors/track"));
-               puts(_("\tv\tverify the partition table"));
-               puts(_("\tw\twrite table to disk and exit"));
-       } else
-       if (LABEL_IS_AIX) {
-               puts(_("Command action"));
-               puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
-               puts(_("\tc\tchange number of cylinders"));
-               puts(_("\td\tprint the raw data in the partition table"));
-               puts(_("\te\tlist extended partitions"));          /* !sun */
-               puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
-               puts(_("\th\tchange number of heads"));
-               puts(_("\tm\tprint this menu"));
-               puts(_("\tp\tprint the partition table"));
-               puts(_("\tq\tquit without saving changes"));
-               puts(_("\tr\treturn to main menu"));
-               puts(_("\ts\tchange number of sectors/track"));
-               puts(_("\tv\tverify the partition table"));
-               puts(_("\tw\twrite table to disk and exit"));
-       }  else {
-               puts(_("Command action"));
-               puts(_("\tb\tmove beginning of data in a partition")); /* !sun */
-               puts(_("\tc\tchange number of cylinders"));
-               puts(_("\td\tprint the raw data in the partition table"));
-               puts(_("\te\tlist extended partitions"));          /* !sun */
-               puts(_("\tf\tfix partition order"));               /* !sun, !aix, !sgi */
-#ifdef CONFIG_FEATURE_SGI_LABEL
-               puts(_("\tg\tcreate an IRIX (SGI) partition table"));/* sgi */
+               puts("a\tchange number of alternate cylinders");      /*sun*/
+               puts("c\tchange number of cylinders");
+               puts("d\tprint the raw data in the partition table");
+               puts("e\tchange number of extra sectors per cylinder");/*sun*/
+               puts("h\tchange number of heads");
+               puts("i\tchange interleave factor");                  /*sun*/
+               puts("o\tchange rotation speed (rpm)");               /*sun*/
+               puts("p\tprint the partition table");
+               puts("q\tquit without saving changes");
+               puts("r\treturn to main menu");
+               puts("s\tchange number of sectors/track");
+               puts("v\tverify the partition table");
+               puts("w\twrite table to disk and exit");
+               puts("y\tchange number of physical cylinders");       /*sun*/
+       } else if (LABEL_IS_SGI) {
+               puts("b\tmove beginning of data in a partition"); /* !sun */
+               puts("c\tchange number of cylinders");
+               puts("d\tprint the raw data in the partition table");
+               puts("e\tlist extended partitions");          /* !sun */
+               puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
+               puts("h\tchange number of heads");
+               puts("p\tprint the partition table");
+               puts("q\tquit without saving changes");
+               puts("r\treturn to main menu");
+               puts("s\tchange number of sectors/track");
+               puts("v\tverify the partition table");
+               puts("w\twrite table to disk and exit");
+       } else if (LABEL_IS_AIX) {
+               puts("b\tmove beginning of data in a partition"); /* !sun */
+               puts("c\tchange number of cylinders");
+               puts("d\tprint the raw data in the partition table");
+               puts("e\tlist extended partitions");          /* !sun */
+               puts("g\tcreate an IRIX (SGI) partition table");/* sgi */
+               puts("h\tchange number of heads");
+               puts("p\tprint the partition table");
+               puts("q\tquit without saving changes");
+               puts("r\treturn to main menu");
+               puts("s\tchange number of sectors/track");
+               puts("v\tverify the partition table");
+               puts("w\twrite table to disk and exit");
+       } else {
+               puts("b\tmove beginning of data in a partition"); /* !sun */
+               puts("c\tchange number of cylinders");
+               puts("d\tprint the raw data in the partition table");
+               puts("e\tlist extended partitions");          /* !sun */
+               puts("f\tfix partition order");               /* !sun, !aix, !sgi */
+#if ENABLE_FEATURE_SGI_LABEL
+               puts("g\tcreate an IRIX (SGI) partition table");/* sgi */

 #endif
 #endif

-               puts(_("\th\tchange number of heads"));
-               puts(_("\tm\tprint this menu"));
-               puts(_("\tp\tprint the partition table"));
-               puts(_("\tq\tquit without saving changes"));
-               puts(_("\tr\treturn to main menu"));
-               puts(_("\ts\tchange number of sectors/track"));
-               puts(_("\tv\tverify the partition table"));
-               puts(_("\tw\twrite table to disk and exit"));
+               puts("h\tchange number of heads");
+               puts("p\tprint the partition table");
+               puts("q\tquit without saving changes");
+               puts("r\treturn to main menu");
+               puts("s\tchange number of sectors/track");
+               puts("v\tverify the partition table");
+               puts("w\twrite table to disk and exit");

        }
 }
 #endif /* ADVANCED mode */
 
        }
 }
 #endif /* ADVANCED mode */
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static const struct systypes *
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static const char *const *

 get_sys_types(void)
 {
        return (
 get_sys_types(void)
 {
        return (


@@ -872,22 +971,41 @@ get_sys_types(void)
 }
 #else
 #define get_sys_types() i386_sys_types
 }
 #else
 #define get_sys_types() i386_sys_types

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif

 
 

-static const char *partition_type(unsigned char type)
+static const char *
+partition_type(unsigned char type)

 {
        int i;
 {
        int i;

-       const struct systypes *types = get_sys_types();
+       const char *const *types = get_sys_types();

 
 

-       for (i = 0; types[i].name; i++)
-               if ((unsigned char )types[i].name[0] == type)
-                       return types[i].name + 1;
+       for (i = 0; types[i]; i++)
+               if ((unsigned char)types[i][0] == type)
+                       return types[i] + 1;

 
 

-       return _("Unknown");
+       return "Unknown";

 }
 
 }
 

+static int
+is_cleared_partition(const struct partition *p)
+{
+       /* We consider partition "cleared" only if it has only zeros */
+       const char *cp = (const char *)p;
+       int cnt = sizeof(*p);
+       char bits = 0;
+       while (--cnt >= 0)
+               bits |= *cp++;
+       return (bits == 0);
+}
+
+static void
+clear_partition(struct partition *p)
+{
+       if (p)
+               memset(p, 0, sizeof(*p));
+}

 
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

 static int
 get_sysid(int i)
 {
 static int
 get_sysid(int i)
 {


@@ -896,117 +1014,106 @@ get_sysid(int i)
                                ptes[i].part_table->sys_ind);
 }
 
                                ptes[i].part_table->sys_ind);
 }
 

-void list_types(const struct systypes *sys)
+static void
+list_types(const char *const *sys)

 {
 {

-       uint last[4], done = 0, next = 0, size;
+       enum { COLS = 3 };
+
+       unsigned last[COLS];
+       unsigned done, next, size;

        int i;
 
        int i;
 

-       for (i = 0; sys[i].name; i++);
-       size = i;
+       for (size = 0; sys[size]; size++)
+               continue;

 
 

-       for (i = 3; i >= 0; i--)
-               last[3 - i] = done += (size + i - done) / (i + 1);
-       i = done = 0;
+       done = 0;
+       for (i = COLS-1; i >= 0; i--) {
+               done += (size + i - done) / (i + 1);
+               last[COLS-1 - i] = done;
+       }

 
 

+       i = done = next = 0;

        do {
        do {

-               printf("%c%2x  %-15.15s", i ? ' ' : '\n',
-                       (unsigned char)sys[next].name[0],
-                       partition_type((unsigned char)sys[next].name[0]));
+               printf("%c%2x %-22.22s", i ? ' ' : '\n',
+                       (unsigned char)sys[next][0],
+                       sys[next] + 1);

                next = last[i++] + done;
                next = last[i++] + done;

-               if (i > 3 || next >= last[i]) {
+               if (i >= COLS || next >= last[i]) {

                        i = 0;
                        next = ++done;
                }
        } while (done < last[0]);
                        i = 0;
                        next = ++done;
                }
        } while (done < last[0]);

-       putchar('\n');
+       bb_putchar('\n');

 }
 }

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */

 
 

-static int
-is_cleared_partition(const struct partition *p)
-{
-       return !(!p || p->boot_ind || p->head || p->sector || p->cyl ||
-                p->sys_ind || p->end_head || p->end_sector || p->end_cyl ||
-                get_start_sect(p) || get_nr_sects(p));
-}
+#define set_hsc(h, s, c, sector) do \
+{ \
+       s = sector % g_sectors + 1;  \
+       sector /= g_sectors;         \
+       h = sector % g_heads;        \
+       sector /= g_heads;           \
+       c = sector & 0xff;           \
+       s |= (sector >> 2) & 0xc0;   \
+} while (0)

 
 

-static void
-clear_partition(struct partition *p)
+static void set_hsc_start_end(struct partition *p, sector_t start, sector_t stop)

 {
 {

-       if (!p)
-               return;
-       memset(p, 0, sizeof(struct partition));
+       if (dos_compatible_flag && (start / (g_sectors * g_heads) > 1023))
+               start = g_heads * g_sectors * 1024 - 1;
+       set_hsc(p->head, p->sector, p->cyl, start);
+
+       if (dos_compatible_flag && (stop / (g_sectors * g_heads) > 1023))
+               stop = g_heads * g_sectors * 1024 - 1;
+       set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);

 }
 
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE

 static void
 static void

-set_partition(int i, int doext, off_t start, off_t stop, int sysid)
+set_partition(int i, int doext, sector_t start, sector_t stop, int sysid)

 {
        struct partition *p;
 {
        struct partition *p;

-       off_t offset;
+       sector_t offset;

 
        if (doext) {
                p = ptes[i].ext_pointer;
                offset = extended_offset;
        } else {
                p = ptes[i].part_table;
 
        if (doext) {
                p = ptes[i].ext_pointer;
                offset = extended_offset;
        } else {
                p = ptes[i].part_table;

-               offset = ptes[i].offset;
+               offset = ptes[i].offset_from_dev_start;

        }
        p->boot_ind = 0;
        p->sys_ind = sysid;
        set_start_sect(p, start - offset);
        set_nr_sects(p, stop - start + 1);
        }
        p->boot_ind = 0;
        p->sys_ind = sysid;
        set_start_sect(p, start - offset);
        set_nr_sects(p, stop - start + 1);

-       if (dos_compatible_flag && (start/(sectors*heads) > 1023))
-               start = heads*sectors*1024 - 1;
-       set_hsc(p->head, p->sector, p->cyl, start);
-       if (dos_compatible_flag && (stop/(sectors*heads) > 1023))
-               stop = heads*sectors*1024 - 1;
-       set_hsc(p->end_head, p->end_sector, p->end_cyl, stop);
+       set_hsc_start_end(p, start, stop);

        ptes[i].changed = 1;
 }
 #endif
 
        ptes[i].changed = 1;
 }
 #endif
 

-static int
-test_c(const char **m, const char *mesg)
-{
-       int val = 0;
-       if (!*m)
-               printf(_("You must set"));
-       else {
-               printf(" %s", *m);
-               val = 1;
-       }
-       *m = mesg;
-       return val;
-}
-

 static int
 warn_geometry(void)
 {
 static int
 warn_geometry(void)
 {

-       const char *m = NULL;
-       int prev = 0;
-
-       if (!heads)
-               prev = test_c(&m, _("heads"));
-       if (!sectors)
-               prev = test_c(&m, _("sectors"));
-       if (!cylinders)
-               prev = test_c(&m, _("cylinders"));
-       if (!m)
+       if (g_heads && g_sectors && g_cylinders)

                return 0;
 
                return 0;
 

-       printf("%s%s.\n"
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-               "You can do this from the extra functions menu.\n"
+       printf("Unknown value(s) for:");
+       if (!g_heads)
+               printf(" heads");
+       if (!g_sectors)
+               printf(" sectors");
+       if (!g_cylinders)
+               printf(" cylinders");
+#if ENABLE_FEATURE_FDISK_WRITABLE
+       puts(" (settable in the extra functions menu)");
+#else
+       bb_putchar('\n');

 #endif
 #endif

-               , prev ? _(" and ") : " ", m);
-

        return 1;
 }
 
        return 1;
 }
 

-static void update_units(void)
+static void
+update_units(void)

 {
 {

-       int cyl_units = heads * sectors;
+       int cyl_units = g_heads * g_sectors;

 
        if (display_in_cyl_units && cyl_units)
                units_per_sector = cyl_units;
 
        if (display_in_cyl_units && cyl_units)
                units_per_sector = cyl_units;


@@ -1014,19 +1121,19 @@ static void update_units(void)
                units_per_sector = 1;   /* in sectors */
 }
 
                units_per_sector = 1;   /* in sectors */
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

 static void
 warn_cylinders(void)
 {
 static void
 warn_cylinders(void)
 {

-       if (LABEL_IS_DOS && cylinders > 1024 && !nowarn)
-               printf(_("\n"
-"The number of cylinders for this disk is set to %d.\n"
+       if (LABEL_IS_DOS && g_cylinders > 1024 && !nowarn)
+               printf("\n"
+"The number of cylinders for this disk is set to %u.\n"

 "There is nothing wrong with that, but this is larger than 1024,\n"
 "and could in certain setups cause problems with:\n"
 "1) software that runs at boot time (e.g., old versions of LILO)\n"
 "2) booting and partitioning software from other OSs\n"
 "There is nothing wrong with that, but this is larger than 1024,\n"
 "and could in certain setups cause problems with:\n"
 "1) software that runs at boot time (e.g., old versions of LILO)\n"
 "2) booting and partitioning software from other OSs\n"

-"   (e.g., DOS FDISK, OS/2 FDISK)\n"),
-                       cylinders);
+"   (e.g., DOS FDISK, OS/2 FDISK)\n",
+                       g_cylinders);

 }
 #endif
 
 }
 #endif
 


@@ -1043,21 +1150,21 @@ read_extended(int ext)
 
        p = pex->part_table;
        if (!get_start_sect(p)) {
 
        p = pex->part_table;
        if (!get_start_sect(p)) {

-               printf(_("Bad offset in primary extended partition\n"));
+               puts("Bad offset in primary extended partition");

                return;
        }
 
        while (IS_EXTENDED(p->sys_ind)) {
                return;
        }
 
        while (IS_EXTENDED(p->sys_ind)) {

-               struct pte *pe = &ptes[partitions];
+               struct pte *pe = &ptes[g_partitions];

 
 

-               if (partitions >= MAXIMUM_PARTS) {
+               if (g_partitions >= MAXIMUM_PARTS) {

                        /* This is not a Linux restriction, but
                           this program uses arrays of size MAXIMUM_PARTS.
                        /* This is not a Linux restriction, but
                           this program uses arrays of size MAXIMUM_PARTS.

-                          Do not try to `improve' this test. */
-                       struct pte *pre = &ptes[partitions-1];
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-                       printf(_("Warning: deleting partitions after %d\n"),
-                               partitions);
+                          Do not try to 'improve' this test. */
+                       struct pte *pre = &ptes[g_partitions - 1];
+#if ENABLE_FEATURE_FDISK_WRITABLE
+                       printf("Warning: deleting partitions after %u\n",
+                               g_partitions);

                        pre->changed = 1;
 #endif
                        clear_partition(pre->ext_pointer);
                        pre->changed = 1;
 #endif
                        clear_partition(pre->ext_pointer);


@@ -1073,16 +1180,16 @@ read_extended(int ext)
                for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) {
                        if (IS_EXTENDED(p->sys_ind)) {
                                if (pe->ext_pointer)
                for (i = 0; i < 4; i++, p++) if (get_nr_sects(p)) {
                        if (IS_EXTENDED(p->sys_ind)) {
                                if (pe->ext_pointer)

-                                       printf(_("Warning: extra link "
+                                       printf("Warning: extra link "

                                                "pointer in partition table"
                                                "pointer in partition table"

-                                               " %d\n"), partitions + 1);
+                                               " %u\n", g_partitions + 1);

                                else
                                        pe->ext_pointer = p;
                        } else if (p->sys_ind) {
                                if (pe->part_table)
                                else
                                        pe->ext_pointer = p;
                        } else if (p->sys_ind) {
                                if (pe->part_table)

-                                       printf(_("Warning: ignoring extra "
+                                       printf("Warning: ignoring extra "

                                                  "data in partition table"
                                                  "data in partition table"

-                                                 " %d\n"), partitions + 1);
+                                                 " %u\n", g_partitions + 1);

                                else
                                        pe->part_table = p;
                        }
                                else
                                        pe->part_table = p;
                        }


@@ -1103,18 +1210,19 @@ read_extended(int ext)
                }
 
                p = pe->ext_pointer;
                }
 
                p = pe->ext_pointer;

-               partitions++;
+               g_partitions++;

        }
 
        }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

        /* remove empty links */
  remove:
        /* remove empty links */
  remove:

-       for (i = 4; i < partitions; i++) {
+       for (i = 4; i < g_partitions; i++) {

                struct pte *pe = &ptes[i];
 
                struct pte *pe = &ptes[i];
 

-               if (!get_nr_sects(pe->part_table) &&
-                       (partitions > 5 || ptes[4].part_table->sys_ind)) {
-                       printf("omitting empty partition (%d)\n", i+1);
+               if (!get_nr_sects(pe->part_table)
+                && (g_partitions > 5 || ptes[4].part_table->sys_ind)
+               ) {
+                       printf("Omitting empty partition (%u)\n", i+1);

                        delete_partition(i);
                        goto remove;    /* numbering changed */
                }
                        delete_partition(i);
                        goto remove;    /* numbering changed */
                }


@@ -1122,44 +1230,38 @@ read_extended(int ext)
 #endif
 }
 
 #endif
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

 static void
 create_doslabel(void)
 {
 static void
 create_doslabel(void)
 {

-       int i;
-
-       printf(
-       _("Building a new DOS disklabel. Changes will remain in memory only,\n"
-         "until you decide to write them. After that, of course, the previous\n"
-         "content won't be recoverable.\n\n"));
+       printf(msg_building_new_label, "DOS disklabel");

 
 

-       current_label_type = label_dos;
-
-#ifdef CONFIG_FEATURE_OSF_LABEL
+       current_label_type = LABEL_DOS;
+#if ENABLE_FEATURE_OSF_LABEL

        possibly_osf_label = 0;
 #endif
        possibly_osf_label = 0;
 #endif

-       partitions = 4;
+       g_partitions = 4;

 
 

-       for (i = 510-64; i < 510; i++)
-               MBRbuffer[i] = 0;
+       memset(&MBRbuffer[510 - 4*16], 0, 4*16);

        write_part_table_flag(MBRbuffer);
        extended_offset = 0;
        set_all_unchanged();
        set_changed(0);
        write_part_table_flag(MBRbuffer);
        extended_offset = 0;
        set_all_unchanged();
        set_changed(0);

-       get_boot(create_empty_dos);
+       get_boot(CREATE_EMPTY_DOS);

 }
 }

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif

 
 static void
 get_sectorsize(void)
 {
        if (!user_set_sector_size) {
                int arg;
 
 static void
 get_sectorsize(void)
 {
        if (!user_set_sector_size) {
                int arg;

-               if (ioctl(fd, BLKSSZGET, &arg) == 0)
+               if (ioctl(dev_fd, BLKSSZGET, &arg) == 0)

                        sector_size = arg;
                if (sector_size != DEFAULT_SECTOR_SIZE)
                        sector_size = arg;
                if (sector_size != DEFAULT_SECTOR_SIZE)

-                       printf(_("Note: sector size is %d (not %d)\n"),
-                                  sector_size, DEFAULT_SECTOR_SIZE);
+                       printf("Note: sector size is %u "
+                               "(not " DEFAULT_SECTOR_SIZE_STR ")\n",
+                               sector_size);

        }
 }
 
        }
 }
 


@@ -1168,7 +1270,7 @@ get_kernel_geometry(void)
 {
        struct hd_geometry geometry;
 
 {
        struct hd_geometry geometry;
 

-       if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
+       if (!ioctl(dev_fd, HDIO_GETGEO, &geometry)) {

                kern_heads = geometry.heads;
                kern_sectors = geometry.sectors;
                /* never use geometry.cylinders - it is truncated */
                kern_heads = geometry.heads;
                kern_sectors = geometry.sectors;
                /* never use geometry.cylinders - it is truncated */


@@ -1212,204 +1314,199 @@ static void
 get_geometry(void)
 {
        int sec_fac;
 get_geometry(void)
 {
        int sec_fac;

-       unsigned long long bytes;       /* really u64 */

 
        get_sectorsize();
        sec_fac = sector_size / 512;
 
        get_sectorsize();
        sec_fac = sector_size / 512;

-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL

        guess_device_type();
 #endif
        guess_device_type();
 #endif

-       heads = cylinders = sectors = 0;
+       g_heads = g_cylinders = g_sectors = 0;

        kern_heads = kern_sectors = 0;
        pt_heads = pt_sectors = 0;
 
        get_kernel_geometry();
        get_partition_table_geometry();
 
        kern_heads = kern_sectors = 0;
        pt_heads = pt_sectors = 0;
 
        get_kernel_geometry();
        get_partition_table_geometry();
 

-       heads = user_heads ? user_heads :
+       g_heads = user_heads ? user_heads :

                pt_heads ? pt_heads :
                kern_heads ? kern_heads : 255;
                pt_heads ? pt_heads :
                kern_heads ? kern_heads : 255;

-       sectors = user_sectors ? user_sectors :
+       g_sectors = user_sectors ? user_sectors :

                pt_sectors ? pt_sectors :
                kern_sectors ? kern_sectors : 63;
                pt_sectors ? pt_sectors :
                kern_sectors ? kern_sectors : 63;

-       if (ioctl(fd, BLKGETSIZE64, &bytes) == 0) {
-               /* got bytes */
-       } else {
-               unsigned long longsectors;
-
-       if (ioctl(fd, BLKGETSIZE, &longsectors))
-               longsectors = 0;
-                       bytes = ((unsigned long long) longsectors) << 9;
-       }
-
-       total_number_of_sectors = (bytes >> 9);
+       total_number_of_sectors = bb_BLKGETSIZE_sectors(dev_fd);

 
        sector_offset = 1;
        if (dos_compatible_flag)
 
        sector_offset = 1;
        if (dos_compatible_flag)

-               sector_offset = sectors;
+               sector_offset = g_sectors;

 
 

-       cylinders = total_number_of_sectors / (heads * sectors * sec_fac);
-       if (!cylinders)
-               cylinders = user_cylinders;
+       g_cylinders = total_number_of_sectors / (g_heads * g_sectors * sec_fac);
+       if (!g_cylinders)
+               g_cylinders = user_cylinders;

 }
 
 /*
 }
 
 /*

- * Read MBR.  Returns:
+ * Opens disk_device and optionally reads MBR.
+ *    If what == OPEN_MAIN:
+ *      Open device, read MBR.  Abort program on short read.  Create empty
+ *      disklabel if the on-disk structure is invalid (WRITABLE mode).
+ *    If what == TRY_ONLY:
+ *      Open device, read MBR.  Return an error if anything is out of place.
+ *      Do not create an empty disklabel.  This is used for the "list"
+ *      operations: "fdisk -l /dev/sda" and "fdisk -l" (all devices).
+ *    If what == CREATE_EMPTY_*:
+ *      This means that get_boot() was called recursively from create_*label().
+ *      Do not re-open the device; just set up the ptes array and print
+ *      geometry warnings.
+ *
+ * Returns:

  *   -1: no 0xaa55 flag present (possibly entire disk BSD)
  *    0: found or created label
  *    1: I/O error
  */
  *   -1: no 0xaa55 flag present (possibly entire disk BSD)
  *    0: found or created label
  *    1: I/O error
  */

-static int
-get_boot(enum action what)
+#if ENABLE_FEATURE_SUN_LABEL || ENABLE_FEATURE_FDISK_WRITABLE
+static int get_boot(enum action what)
+#else
+static int get_boot(void)
+#define get_boot(what) get_boot()
+#endif

 {
 {

-       int i;
-
-       partitions = 4;
+       int i, fd;

 
 

+       g_partitions = 4;

        for (i = 0; i < 4; i++) {
                struct pte *pe = &ptes[i];
        for (i = 0; i < 4; i++) {
                struct pte *pe = &ptes[i];

-

                pe->part_table = pt_offset(MBRbuffer, i);
                pe->ext_pointer = NULL;
                pe->part_table = pt_offset(MBRbuffer, i);
                pe->ext_pointer = NULL;

-               pe->offset = 0;
+               pe->offset_from_dev_start = 0;

                pe->sectorbuffer = MBRbuffer;
                pe->sectorbuffer = MBRbuffer;

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-               pe->changed = (what == create_empty_dos);
+#if ENABLE_FEATURE_FDISK_WRITABLE
+               pe->changed = (what == CREATE_EMPTY_DOS);

 #endif
        }
 
 #endif
        }
 

-#ifdef CONFIG_FEATURE_SUN_LABEL
-       if (what == create_empty_sun && check_sun_label())
-               return 0;
-#endif
+#if ENABLE_FEATURE_FDISK_WRITABLE
+// ALERT! highly idiotic design!
+// We end up here when we call get_boot() recursively
+// via get_boot() [table is bad] -> create_doslabel() -> get_boot(CREATE_EMPTY_DOS).
+// or get_boot() [table is bad] -> create_sunlabel() -> get_boot(CREATE_EMPTY_SUN).
+// (just factor out re-init of ptes[0,1,2,3] in a separate fn instead?)
+// So skip opening device _again_...
+       if (what == CREATE_EMPTY_DOS  IF_FEATURE_SUN_LABEL(|| what == CREATE_EMPTY_SUN))
+               goto created_table;

 
 

-       memset(MBRbuffer, 0, 512);
+       fd = open(disk_device, (option_mask32 & OPT_l) ? O_RDONLY : O_RDWR);

 
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-       if (what == create_empty_dos)
-               goto got_dos_table;             /* skip reading disk */
-
-       if ((fd = open(disk_device, type_open)) < 0) {
-               if ((fd = open(disk_device, O_RDONLY)) < 0) {
-                       if (what == try_only)
+       if (fd < 0) {
+               fd = open(disk_device, O_RDONLY);
+               if (fd < 0) {
+                       if (what == TRY_ONLY)

                                return 1;
                        fdisk_fatal(unable_to_open);
                                return 1;
                        fdisk_fatal(unable_to_open);

-               } else
-                       printf(_("You will not be able to write "
-                               "the partition table.\n"));
+               }
+               printf("'%s' is opened for read only\n", disk_device);

        }
        }

-
-       if (512 != read(fd, MBRbuffer, 512)) {
-               if (what == try_only)
+       xmove_fd(fd, dev_fd);
+       if (512 != full_read(dev_fd, MBRbuffer, 512)) {
+               if (what == TRY_ONLY) {
+                       close_dev_fd();

                        return 1;
                        return 1;

+               }

                fdisk_fatal(unable_to_read);
        }
 #else
                fdisk_fatal(unable_to_read);
        }
 #else

-       if ((fd = open(disk_device, O_RDONLY)) < 0)
+       fd = open(disk_device, O_RDONLY);
+       if (fd < 0)

                return 1;
                return 1;

-       if (512 != read(fd, MBRbuffer, 512))
+       if (512 != full_read(fd, MBRbuffer, 512)) {
+               close(fd);

                return 1;
                return 1;

+       }
+       xmove_fd(fd, dev_fd);

 #endif
 
        get_geometry();
 #endif
 
        get_geometry();

-

        update_units();
 
        update_units();
 

-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL

        if (check_sun_label())
                return 0;
 #endif
        if (check_sun_label())
                return 0;
 #endif

-
-#ifdef CONFIG_FEATURE_SGI_LABEL
+#if ENABLE_FEATURE_SGI_LABEL

        if (check_sgi_label())
                return 0;
 #endif
        if (check_sgi_label())
                return 0;
 #endif

-
-#ifdef CONFIG_FEATURE_AIX_LABEL
+#if ENABLE_FEATURE_AIX_LABEL

        if (check_aix_label())
                return 0;
 #endif
        if (check_aix_label())
                return 0;
 #endif

-
-#ifdef CONFIG_FEATURE_OSF_LABEL
+#if ENABLE_FEATURE_GPT_LABEL
+       if (check_gpt_label())
+               return 0;
+#endif
+#if ENABLE_FEATURE_OSF_LABEL

        if (check_osf_label()) {
                possibly_osf_label = 1;
                if (!valid_part_table_flag(MBRbuffer)) {
        if (check_osf_label()) {
                possibly_osf_label = 1;
                if (!valid_part_table_flag(MBRbuffer)) {

-                       current_label_type = label_osf;
+                       current_label_type = LABEL_OSF;

                        return 0;
                }
                        return 0;
                }

-               printf(_("This disk has both DOS and BSD magic.\n"
-                        "Give the 'b' command to go to BSD mode.\n"));
+               puts("This disk has both DOS and BSD magic.\n"
+                    "Give the 'b' command to go to BSD mode.");

        }
 #endif
 
        }
 #endif
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
- got_dos_table:
-#endif
-
-       if (!valid_part_table_flag(MBRbuffer)) {
-#ifndef CONFIG_FEATURE_FDISK_WRITABLE
+#if !ENABLE_FEATURE_FDISK_WRITABLE
+       if (!valid_part_table_flag(MBRbuffer))

                return -1;
 #else
                return -1;
 #else

-               switch (what) {
-               case fdisk:
-                       printf(_("Device contains neither a valid DOS "
-                                 "partition table, nor Sun, SGI or OSF "
-                                 "disklabel\n"));
+       if (!valid_part_table_flag(MBRbuffer)) {
+               if (what == OPEN_MAIN) {
+                       puts("Device contains neither a valid DOS "
+                            "partition table, nor Sun, SGI, OSF or GPT "
+                            "disklabel");

 #ifdef __sparc__
 #ifdef __sparc__

-#ifdef CONFIG_FEATURE_SUN_LABEL
-                       create_sunlabel();
-#endif
+                       IF_FEATURE_SUN_LABEL(create_sunlabel();)

 #else
                        create_doslabel();
 #endif
                        return 0;
 #else
                        create_doslabel();
 #endif
                        return 0;

-               case try_only:
-                       return -1;
-               case create_empty_dos:
-#ifdef CONFIG_FEATURE_SUN_LABEL
-               case create_empty_sun:
-#endif
-                       break;
-               default:
-                       bb_error_msg_and_die(_("internal error"));

                }
                }

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+               /* TRY_ONLY: */
+               return -1;

        }
        }

+ created_table:
+#endif /* FEATURE_FDISK_WRITABLE */

 
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-       warn_cylinders();
-#endif
+
+       IF_FEATURE_FDISK_WRITABLE(warn_cylinders();)

        warn_geometry();
 
        for (i = 0; i < 4; i++) {
        warn_geometry();
 
        for (i = 0; i < 4; i++) {

-               struct pte *pe = &ptes[i];
-
-               if (IS_EXTENDED(pe->part_table->sys_ind)) {
-                       if (partitions != 4)
-                               printf(_("Ignoring extra extended "
-                                       "partition %d\n"), i + 1);
+               if (IS_EXTENDED(ptes[i].part_table->sys_ind)) {
+                       if (g_partitions != 4)
+                               printf("Ignoring extra extended "
+                                       "partition %u\n", i + 1);

                        else
                                read_extended(i);
                }
        }
 
                        else
                                read_extended(i);
                }
        }
 

-       for (i = 3; i < partitions; i++) {
+       for (i = 3; i < g_partitions; i++) {

                struct pte *pe = &ptes[i];
                struct pte *pe = &ptes[i];

-

                if (!valid_part_table_flag(pe->sectorbuffer)) {
                if (!valid_part_table_flag(pe->sectorbuffer)) {

-                       printf(_("Warning: invalid flag 0x%04x of partition "
-                               "table %d will be corrected by w(rite)\n"),
-                               part_table_flag(pe->sectorbuffer), i + 1);
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-                       pe->changed = 1;
-#endif
+                       printf("Warning: invalid flag 0x%02x,0x%02x of partition "
+                               "table %u will be corrected by w(rite)\n",
+                               pe->sectorbuffer[510],
+                               pe->sectorbuffer[511],
+                               i + 1);
+                       IF_FEATURE_FDISK_WRITABLE(pe->changed = 1;)

                }
        }
 
        return 0;
 }
 
                }
        }
 
        return 0;
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

 /*
  * Print the message MESG, then read an integer between LOW and HIGH (inclusive).
  * If the user hits Enter, DFLT is returned.
 /*
  * Print the message MESG, then read an integer between LOW and HIGH (inclusive).
  * If the user hits Enter, DFLT is returned.


@@ -1417,10 +1514,10 @@ get_boot(enum action what)
  *
  * There is no default if DFLT is not between LOW and HIGH.
  */
  *
  * There is no default if DFLT is not between LOW and HIGH.
  */

-static uint
-read_int(uint low, uint dflt, uint high, uint base, char *mesg)
+static sector_t
+read_int(sector_t low, sector_t dflt, sector_t high, sector_t base, const char *mesg)

 {
 {

-       uint i;
+       sector_t value;

        int default_ok = 1;
        const char *fmt = "%s (%u-%u, default %u): ";
 
        int default_ok = 1;
        const char *fmt = "%s (%u-%u, default %u): ";
 


@@ -1443,8 +1540,10 @@ read_int(uint low, uint dflt, uint high, uint base, char *mesg)
                        int minus = (*line_ptr == '-');
                        int absolute = 0;
 
                        int minus = (*line_ptr == '-');
                        int absolute = 0;
 

-                       i = atoi(line_ptr + 1);
+                       value = atoi(line_ptr + 1);

 
 

+                       /* (1) if 2nd char is digit, use_default = 0.
+                        * (2) move line_ptr to first non-digit. */

                        while (isdigit(*++line_ptr))
                                use_default = 0;
 
                        while (isdigit(*++line_ptr))
                                use_default = 0;
 


@@ -1452,7 +1551,7 @@ read_int(uint low, uint dflt, uint high, uint base, char *mesg)
                        case 'c':
                        case 'C':
                                if (!display_in_cyl_units)
                        case 'c':
                        case 'C':
                                if (!display_in_cyl_units)

-                                       i *= heads * sectors;
+                                       value *= g_heads * g_sectors;

                                break;
                        case 'K':
                                absolute = 1024;
                                break;
                        case 'K':
                                absolute = 1024;


@@ -1472,42 +1571,43 @@ read_int(uint low, uint dflt, uint high, uint base, char *mesg)
                                break;
                        }
                        if (absolute) {
                                break;
                        }
                        if (absolute) {

-                               unsigned long long bytes;
+                               ullong bytes;

                                unsigned long unit;
 
                                unsigned long unit;
 

-                               bytes = (unsigned long long) i * absolute;
+                               bytes = (ullong) value * absolute;

                                unit = sector_size * units_per_sector;
                                bytes += unit/2; /* round */
                                bytes /= unit;
                                unit = sector_size * units_per_sector;
                                bytes += unit/2; /* round */
                                bytes /= unit;

-                               i = bytes;
+                               value = bytes;

                        }
                        if (minus)
                        }
                        if (minus)

-                               i = -i;
-                       i += base;
+                               value = -value;
+                       value += base;

                } else {
                } else {

-                       i = atoi(line_ptr);
+                       value = atoi(line_ptr);

                        while (isdigit(*line_ptr)) {
                                line_ptr++;
                                use_default = 0;
                        }
                }
                        while (isdigit(*line_ptr)) {
                                line_ptr++;
                                use_default = 0;
                        }
                }

-               if (use_default)
-                       printf(_("Using default value %u\n"), i = dflt);
-               if (i >= low && i <= high)
+               if (use_default) {
+                       value = dflt;
+                       printf("Using default value %u\n", value);
+               }
+               if (value >= low && value <= high)

                        break;
                        break;

-               else
-                       printf(_("Value is out of range\n"));
+               puts("Value is out of range");

        }
        }

-       return i;
+       return value;

 }
 
 }
 

-static int
-get_partition(int warn, int max)
+static unsigned
+get_partition(int warn, unsigned max)

 {
        struct pte *pe;
 {
        struct pte *pe;

-       int i;
+       unsigned i;

 
 

-       i = read_int(1, 0, max, 0, _("Partition number")) - 1;
+       i = read_int(1, 0, max, 0, "Partition number") - 1;

        pe = &ptes[i];
 
        if (warn) {
        pe = &ptes[i];
 
        if (warn) {


@@ -1515,17 +1615,17 @@ get_partition(int warn, int max)
                 || (LABEL_IS_SUN && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id))
                 || (LABEL_IS_SGI && !sgi_get_num_sectors(i))
                ) {
                 || (LABEL_IS_SUN && (!sunlabel->partitions[i].num_sectors || !sunlabel->infos[i].id))
                 || (LABEL_IS_SGI && !sgi_get_num_sectors(i))
                ) {

-                       printf(_("Warning: partition %d has empty type\n"), i+1);
+                       printf("Warning: partition %u has empty type\n", i+1);

                }
        }
        return i;
 }
 
 static int
                }
        }
        return i;
 }
 
 static int

-get_existing_partition(int warn, int max)
+get_existing_partition(int warn, unsigned max)

 {
        int pno = -1;
 {
        int pno = -1;

-       int i;
+       unsigned i;

 
        for (i = 0; i < max; i++) {
                struct pte *pe = &ptes[i];
 
        for (i = 0; i < max; i++) {
                struct pte *pe = &ptes[i];


@@ -1538,10 +1638,10 @@ get_existing_partition(int warn, int max)
                }
        }
        if (pno >= 0) {
                }
        }
        if (pno >= 0) {

-               printf(_("Selected partition %d\n"), pno+1);
+               printf("Selected partition %u\n", pno+1);

                return pno;
        }
                return pno;
        }

-       printf(_("No partition is defined yet!\n"));
+       puts("No partition is defined yet!");

        return -1;
 
  not_unique:
        return -1;
 
  not_unique:


@@ -1549,10 +1649,10 @@ get_existing_partition(int warn, int max)
 }
 
 static int
 }
 
 static int

-get_nonexisting_partition(int warn, int max)
+get_nonexisting_partition(int warn, unsigned max)

 {
        int pno = -1;
 {
        int pno = -1;

-       int i;
+       unsigned i;

 
        for (i = 0; i < max; i++) {
                struct pte *pe = &ptes[i];
 
        for (i = 0; i < max; i++) {
                struct pte *pe = &ptes[i];


@@ -1565,10 +1665,10 @@ get_nonexisting_partition(int warn, int max)
                }
        }
        if (pno >= 0) {
                }
        }
        if (pno >= 0) {

-               printf(_("Selected partition %d\n"), pno+1);
+               printf("Selected partition %u\n", pno+1);

                return pno;
        }
                return pno;
        }

-       printf(_("All primary partitions have been defined already!\n"));
+       puts("All primary partitions have been defined already!");

        return -1;
 
  not_unique:
        return -1;
 
  not_unique:


@@ -1581,7 +1681,7 @@ change_units(void)
 {
        display_in_cyl_units = !display_in_cyl_units;
        update_units();
 {
        display_in_cyl_units = !display_in_cyl_units;
        update_units();

-       printf(_("Changing display/entry units to %s\n"),
+       printf("Changing display/entry units to %s\n",

                str_units(PLURAL));
 }
 
                str_units(PLURAL));
 }
 


@@ -1592,7 +1692,7 @@ toggle_active(int i)
        struct partition *p = pe->part_table;
 
        if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
        struct partition *p = pe->part_table;
 
        if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)

-               printf(_("WARNING: Partition %d is an extended partition\n"), i + 1);
+               printf("WARNING: Partition %u is an extended partition\n", i + 1);

        p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
        pe->changed = 1;
 }
        p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
        pe->changed = 1;
 }


@@ -1600,14 +1700,13 @@ toggle_active(int i)
 static void
 toggle_dos_compatibility_flag(void)
 {
 static void
 toggle_dos_compatibility_flag(void)
 {

-       dos_compatible_flag = ~dos_compatible_flag;
+       dos_compatible_flag = 1 - dos_compatible_flag;

        if (dos_compatible_flag) {
        if (dos_compatible_flag) {

-               sector_offset = sectors;
-               printf(_("DOS Compatibility flag is set\n"));
-       }
-       else {
+               sector_offset = g_sectors;
+               printf("DOS Compatibility flag is %sset\n", "");
+       } else {

                sector_offset = 1;
                sector_offset = 1;

-               printf(_("DOS Compatibility flag is not set\n"));
+               printf("DOS Compatibility flag is %sset\n", "not ");

        }
 }
 
        }
 }
 


@@ -1637,7 +1736,7 @@ delete_partition(int i)
 
        if (i < 4) {
                if (IS_EXTENDED(p->sys_ind) && i == ext_index) {
 
        if (i < 4) {
                if (IS_EXTENDED(p->sys_ind) && i == ext_index) {

-                       partitions = 4;
+                       g_partitions = 4;

                        ptes[ext_index].ext_pointer = NULL;
                        extended_offset = 0;
                }
                        ptes[ext_index].ext_pointer = NULL;
                        extended_offset = 0;
                }


@@ -1647,7 +1746,7 @@ delete_partition(int i)
 
        if (!q->sys_ind && i > 4) {
                /* the last one in the chain - just delete */
 
        if (!q->sys_ind && i > 4) {
                /* the last one in the chain - just delete */

-               --partitions;
+               --g_partitions;

                --i;
                clear_partition(ptes[i].ext_pointer);
                ptes[i].changed = 1;
                --i;
                clear_partition(ptes[i].ext_pointer);
                ptes[i].changed = 1;


@@ -1660,27 +1759,28 @@ delete_partition(int i)
                        set_start_sect(p, get_start_sect(q));
                        set_nr_sects(p, get_nr_sects(q));
                        ptes[i-1].changed = 1;
                        set_start_sect(p, get_start_sect(q));
                        set_nr_sects(p, get_nr_sects(q));
                        ptes[i-1].changed = 1;

-               } else if (partitions > 5) {    /* 5 will be moved to 4 */
+               } else if (g_partitions > 5) {    /* 5 will be moved to 4 */

                        /* the first logical in a longer chain */
                        pe = &ptes[5];
 
                        if (pe->part_table) /* prevent SEGFAULT */
                                set_start_sect(pe->part_table,
                        /* the first logical in a longer chain */
                        pe = &ptes[5];
 
                        if (pe->part_table) /* prevent SEGFAULT */
                                set_start_sect(pe->part_table,

-                                                  get_partition_start(pe) -
-                                                  extended_offset);
-                       pe->offset = extended_offset;
+                                               get_partition_start_from_dev_start(pe) -
+                                               extended_offset);
+                       pe->offset_from_dev_start = extended_offset;

                        pe->changed = 1;
                }
 
                        pe->changed = 1;
                }
 

-               if (partitions > 5) {
-                       partitions--;
-                       while (i < partitions) {
+               if (g_partitions > 5) {
+                       g_partitions--;
+                       while (i < g_partitions) {

                                ptes[i] = ptes[i+1];
                                i++;
                        }
                                ptes[i] = ptes[i+1];
                                i++;
                        }

-               } else
+               } else {

                        /* the only logical: clear only */
                        clear_partition(ptes[i].part_table);
                        /* the only logical: clear only */
                        clear_partition(ptes[i].part_table);

+               }

        }
 }
 
        }
 }
 


@@ -1694,9 +1794,9 @@ change_sysid(void)
           let the user select a partition, since get_existing_partition()
           only works for Linux like partition tables. */
        if (!LABEL_IS_SGI) {
           let the user select a partition, since get_existing_partition()
           only works for Linux like partition tables. */
        if (!LABEL_IS_SGI) {

-               i = get_existing_partition(0, partitions);
+               i = get_existing_partition(0, g_partitions);

        } else {
        } else {

-               i = get_partition(0, partitions);
+               i = get_partition(0, g_partitions);

        }
        if (i == -1)
                return;
        }
        if (i == -1)
                return;


@@ -1706,46 +1806,48 @@ change_sysid(void)
        /* if changing types T to 0 is allowed, then
           the reverse change must be allowed, too */
        if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) {
        /* if changing types T to 0 is allowed, then
           the reverse change must be allowed, too */
        if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) {

-               printf(_("Partition %d does not exist yet!\n"), i + 1);
+               printf("Partition %u does not exist yet!\n", i + 1);

                return;
        }
        while (1) {
                return;
        }
        while (1) {

-               sys = read_hex (get_sys_types());
+               sys = read_hex(get_sys_types());

 
                if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) {
 
                if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN) {

-                       printf(_("Type 0 means free space to many systems\n"
-                                  "(but not to Linux). Having partitions of\n"
-                                  "type 0 is probably unwise. You can delete\n"
-                                  "a partition using the `d' command.\n"));
+                       puts("Type 0 means free space to many systems\n"
+                               "(but not to Linux). Having partitions of\n"
+                               "type 0 is probably unwise.");

                        /* break; */
                }
 
                if (!LABEL_IS_SUN && !LABEL_IS_SGI) {
                        if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {
                        /* break; */
                }
 
                if (!LABEL_IS_SUN && !LABEL_IS_SGI) {
                        if (IS_EXTENDED(sys) != IS_EXTENDED(p->sys_ind)) {

-                               printf(_("You cannot change a partition into"
-                                          " an extended one or vice versa\n"
-                                          "Delete it first.\n"));
+                               puts("You cannot change a partition into"
+                                       " an extended one or vice versa");

                                break;
                        }
                }
 
                if (sys < 256) {
                                break;
                        }
                }
 
                if (sys < 256) {

+#if ENABLE_FEATURE_SUN_LABEL

                        if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK)
                        if (LABEL_IS_SUN && i == 2 && sys != SUN_WHOLE_DISK)

-                               printf(_("Consider leaving partition 3 "
-                                          "as Whole disk (5),\n"
-                                          "as SunOS/Solaris expects it and "
-                                          "even Linux likes it.\n\n"));
+                               puts("Consider leaving partition 3 "
+                                       "as Whole disk (5),\n"
+                                       "as SunOS/Solaris expects it and "
+                                       "even Linux likes it\n");
+#endif
+#if ENABLE_FEATURE_SGI_LABEL

                        if (LABEL_IS_SGI &&
                                (
                                        (i == 10 && sys != SGI_ENTIRE_DISK) ||
                                        (i == 8 && sys != 0)
                                )
                        if (LABEL_IS_SGI &&
                                (
                                        (i == 10 && sys != SGI_ENTIRE_DISK) ||
                                        (i == 8 && sys != 0)
                                )

-                       ){
-                               printf(_("Consider leaving partition 9 "
-                                          "as volume header (0),\nand "
-                                          "partition 11 as entire volume (6)"
-                                          "as IRIX expects it.\n\n"));
+                       ) {
+                               puts("Consider leaving partition 9 "
+                                       "as volume header (0),\nand "
+                                       "partition 11 as entire volume (6)"
+                                       "as IRIX expects it\n");

                        }
                        }

+#endif

                        if (sys == origsys)
                                break;
                        if (LABEL_IS_SUN) {
                        if (sys == origsys)
                                break;
                        if (LABEL_IS_SUN) {


@@ -1755,45 +1857,44 @@ change_sysid(void)
                        } else
                                p->sys_ind = sys;
 
                        } else
                                p->sys_ind = sys;
 

-                       printf(_("Changed system type of partition %d "
-                               "to %x (%s)\n"), i + 1, sys,
+                       printf("Changed system type of partition %u "
+                               "to %x (%s)\n", i + 1, sys,

                                partition_type(sys));
                        ptes[i].changed = 1;
                                partition_type(sys));
                        ptes[i].changed = 1;

-                       if (is_dos_partition(origsys) ||
-                               is_dos_partition(sys))
-                               dos_changed = 1;
+                       //if (is_dos_partition(origsys) || is_dos_partition(sys))
+                       //      dos_changed = 1;

                        break;
                }
        }
 }
                        break;
                }
        }
 }

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */

 
 
 
 

-/* check_consistency() and long2chs() added Sat Mar 6 12:28:16 1993,
+/* check_consistency() and linear2chs() added Sat Mar 6 12:28:16 1993,

  * faith@cs.unc.edu, based on code fragments from pfdisk by Gordon W. Ross,
  * Jan.  1990 (version 1.2.1 by Gordon W. Ross Aug. 1990; Modified by S.
  * Lubkin Oct.  1991). */
 
 static void
  * faith@cs.unc.edu, based on code fragments from pfdisk by Gordon W. Ross,
  * Jan.  1990 (version 1.2.1 by Gordon W. Ross Aug. 1990; Modified by S.
  * Lubkin Oct.  1991). */
 
 static void

-long2chs(ulong ls, uint *c, uint *h, uint *s)
+linear2chs(unsigned ls, unsigned *c, unsigned *h, unsigned *s)

 {
 {

-       int spc = heads * sectors;
+       int spc = g_heads * g_sectors;

 
        *c = ls / spc;
        ls = ls % spc;
 
        *c = ls / spc;
        ls = ls % spc;

-       *h = ls / sectors;
-       *s = ls % sectors + 1;  /* sectors count from 1 */
+       *h = ls / g_sectors;
+       *s = ls % g_sectors + 1;  /* sectors count from 1 */

 }
 
 static void
 check_consistency(const struct partition *p, int partition)
 {
 }
 
 static void
 check_consistency(const struct partition *p, int partition)
 {

-       uint pbc, pbh, pbs;          /* physical beginning c, h, s */
-       uint pec, peh, pes;          /* physical ending c, h, s */
-       uint lbc, lbh, lbs;          /* logical beginning c, h, s */
-       uint lec, leh, les;          /* logical ending c, h, s */
+       unsigned pbc, pbh, pbs;          /* physical beginning c, h, s */
+       unsigned pec, peh, pes;          /* physical ending c, h, s */
+       unsigned lbc, lbh, lbs;          /* logical beginning c, h, s */
+       unsigned lec, leh, les;          /* logical ending c, h, s */

 
 

-       if (!heads || !sectors || (partition >= 4))
+       if (!g_heads || !g_sectors || (partition >= 4))

                return;         /* do not check extended partitions */
 
 /* physical beginning c, h, s */
                return;         /* do not check extended partitions */
 
 /* physical beginning c, h, s */


@@ -1807,30 +1908,30 @@ check_consistency(const struct partition *p, int partition)
        pes = p->end_sector & 0x3f;
 
 /* compute logical beginning (c, h, s) */
        pes = p->end_sector & 0x3f;
 
 /* compute logical beginning (c, h, s) */

-       long2chs(get_start_sect(p), &lbc, &lbh, &lbs);
+       linear2chs(get_start_sect(p), &lbc, &lbh, &lbs);

 
 /* compute logical ending (c, h, s) */
 
 /* compute logical ending (c, h, s) */

-       long2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);
+       linear2chs(get_start_sect(p) + get_nr_sects(p) - 1, &lec, &leh, &les);

 
 /* Same physical / logical beginning? */
 
 /* Same physical / logical beginning? */

-       if (cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
-               printf(_("Partition %d has different physical/logical "
-                       "beginnings (non-Linux?):\n"), partition + 1);
-               printf(_("     phys=(%d, %d, %d) "), pbc, pbh, pbs);
-               printf(_("logical=(%d, %d, %d)\n"),lbc, lbh, lbs);
+       if (g_cylinders <= 1024 && (pbc != lbc || pbh != lbh || pbs != lbs)) {
+               printf("Partition %u has different physical/logical "
+                       "beginnings (non-Linux?):\n", partition + 1);
+               printf("     phys=(%u, %u, %u) ", pbc, pbh, pbs);
+               printf("logical=(%u, %u, %u)\n", lbc, lbh, lbs);

        }
 
 /* Same physical / logical ending? */
        }
 
 /* Same physical / logical ending? */

-       if (cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
-               printf(_("Partition %d has different physical/logical "
-                       "endings:\n"), partition + 1);
-               printf(_("     phys=(%d, %d, %d) "), pec, peh, pes);
-               printf(_("logical=(%d, %d, %d)\n"),lec, leh, les);
+       if (g_cylinders <= 1024 && (pec != lec || peh != leh || pes != les)) {
+               printf("Partition %u has different physical/logical "
+                       "endings:\n", partition + 1);
+               printf("     phys=(%u, %u, %u) ", pec, peh, pes);
+               printf("logical=(%u, %u, %u)\n", lec, leh, les);

        }
 
 /* Ending on cylinder boundary? */
        }
 
 /* Ending on cylinder boundary? */

-       if (peh != (heads - 1) || pes != sectors) {
-               printf(_("Partition %i does not end on cylinder boundary.\n"),
+       if (peh != (g_heads - 1) || pes != g_sectors) {
+               printf("Partition %u does not end on cylinder boundary\n",

                        partition + 1);
        }
 }
                        partition + 1);
        }
 }


@@ -1838,23 +1939,23 @@ check_consistency(const struct partition *p, int partition)
 static void
 list_disk_geometry(void)
 {
 static void
 list_disk_geometry(void)
 {

-       long long bytes = (total_number_of_sectors << 9);
-       long megabytes = bytes/1000000;
+       ullong bytes = ((ullong)total_number_of_sectors << 9);
+       long megabytes = bytes / 1000000;

 
        if (megabytes < 10000)
 
        if (megabytes < 10000)

-               printf(_("\nDisk %s: %ld MB, %lld bytes\n"),
-                          disk_device, megabytes, bytes);
+               printf("\nDisk %s: %lu MB, %llu bytes\n",
+                       disk_device, megabytes, bytes);

        else
        else

-               printf(_("\nDisk %s: %ld.%ld GB, %lld bytes\n"),
-                          disk_device, megabytes/1000, (megabytes/100)%10, bytes);
-       printf(_("%d heads, %d sectors/track, %d cylinders"),
-                  heads, sectors, cylinders);
+               printf("\nDisk %s: %lu.%lu GB, %llu bytes\n",
+                       disk_device, megabytes/1000, (megabytes/100)%10, bytes);
+       printf("%u heads, %u sectors/track, %u cylinders",
+                  g_heads, g_sectors, g_cylinders);

        if (units_per_sector == 1)
        if (units_per_sector == 1)

-               printf(_(", total %llu sectors"),
-                          total_number_of_sectors / (sector_size/512));
-       printf(_("\nUnits = %s of %d * %d = %d bytes\n\n"),
-                  str_units(PLURAL),
-                  units_per_sector, sector_size, units_per_sector * sector_size);
+               printf(", total %"SECT_FMT"u sectors",
+                       total_number_of_sectors / (sector_size/512));
+       printf("\nUnits = %s of %u * %u = %u bytes\n\n",
+               str_units(PLURAL),
+               units_per_sector, sector_size, units_per_sector * sector_size);

 }
 
 /*
 }
 
 /*


@@ -1867,17 +1968,18 @@ wrong_p_order(int *prev)
 {
        const struct pte *pe;
        const struct partition *p;
 {
        const struct pte *pe;
        const struct partition *p;

-       off_t last_p_start_pos = 0, p_start_pos;
-       int i, last_i = 0;
+       sector_t last_p_start_pos = 0, p_start_pos;
+       unsigned i, last_i = 0;

 
 

-       for (i = 0 ; i < partitions; i++) {
+       for (i = 0; i < g_partitions; i++) {

                if (i == 4) {
                        last_i = 4;
                        last_p_start_pos = 0;
                }
                pe = &ptes[i];
                if (i == 4) {
                        last_i = 4;
                        last_p_start_pos = 0;
                }
                pe = &ptes[i];

-               if ((p = pe->part_table)->sys_ind) {
-                       p_start_pos = get_partition_start(pe);
+               p = pe->part_table;
+               if (p->sys_ind) {
+                       p_start_pos = get_partition_start_from_dev_start(pe);

 
                        if (last_p_start_pos > p_start_pos) {
                                if (prev)
 
                        if (last_p_start_pos > p_start_pos) {
                                if (prev)


@@ -1892,7 +1994,7 @@ wrong_p_order(int *prev)
        return 0;
 }
 
        return 0;
 }
 

-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED

 /*
  * Fix the chain of logicals.
  * extended_offset is unchanged, the set of sectors used is unchanged
 /*
  * Fix the chain of logicals.
  * extended_offset is unchanged, the set of sectors used is unchanged


@@ -1915,12 +2017,12 @@ fix_chain_of_logicals(void)
        /* Stage 1: sort sectors but leave sector of part 4 */
        /* (Its sector is the global extended_offset.) */
  stage1:
        /* Stage 1: sort sectors but leave sector of part 4 */
        /* (Its sector is the global extended_offset.) */
  stage1:

-       for (j = 5; j < partitions-1; j++) {
-               oj = ptes[j].offset;
-               ojj = ptes[j+1].offset;
+       for (j = 5; j < g_partitions - 1; j++) {
+               oj = ptes[j].offset_from_dev_start;
+               ojj = ptes[j+1].offset_from_dev_start;

                if (oj > ojj) {
                if (oj > ojj) {

-                       ptes[j].offset = ojj;
-                       ptes[j+1].offset = oj;
+                       ptes[j].offset_from_dev_start = ojj;
+                       ptes[j+1].offset_from_dev_start = oj;

                        pj = ptes[j].part_table;
                        set_start_sect(pj, get_start_sect(pj)+oj-ojj);
                        pjj = ptes[j+1].part_table;
                        pj = ptes[j].part_table;
                        set_start_sect(pj, get_start_sect(pj)+oj-ojj);
                        pjj = ptes[j+1].part_table;


@@ -1935,13 +2037,13 @@ fix_chain_of_logicals(void)
 
        /* Stage 2: sort starting sectors */
  stage2:
 
        /* Stage 2: sort starting sectors */
  stage2:

-       for (j = 4; j < partitions-1; j++) {
+       for (j = 4; j < g_partitions - 1; j++) {

                pj = ptes[j].part_table;
                pjj = ptes[j+1].part_table;
                sj = get_start_sect(pj);
                sjj = get_start_sect(pjj);
                pj = ptes[j].part_table;
                pjj = ptes[j+1].part_table;
                sj = get_start_sect(pj);
                sjj = get_start_sect(pjj);

-               oj = ptes[j].offset;
-               ojj = ptes[j+1].offset;
+               oj = ptes[j].offset_from_dev_start;
+               ojj = ptes[j+1].offset_from_dev_start;

                if (oj+sj > ojj+sjj) {
                        tmp = *pj;
                        *pj = *pjj;
                if (oj+sj > ojj+sjj) {
                        tmp = *pj;
                        *pj = *pjj;


@@ -1953,7 +2055,7 @@ fix_chain_of_logicals(void)
        }
 
        /* Probably something was changed */
        }
 
        /* Probably something was changed */

-       for (j = 4; j < partitions; j++)
+       for (j = 4; j < g_partitions; j++)

                ptes[j].changed = 1;
 }
 
                ptes[j].changed = 1;
 }
 


@@ -1965,7 +2067,7 @@ fix_partition_table_order(void)
        int i,k;
 
        if (!wrong_p_order(NULL)) {
        int i,k;
 
        if (!wrong_p_order(NULL)) {

-               printf(_("Nothing to do. Ordering is correct already.\n\n"));
+               puts("Ordering is already correct\n");

                return;
        }
 
                return;
        }
 


@@ -1993,8 +2095,7 @@ fix_partition_table_order(void)
        if (i)
                fix_chain_of_logicals();
 
        if (i)
                fix_chain_of_logicals();
 

-       printf("Done.\n");
-
+       puts("Done");

 }
 #endif
 
 }
 #endif
 


@@ -2008,10 +2109,14 @@ list_table(int xtra)
                sun_list_table(xtra);
                return;
        }
                sun_list_table(xtra);
                return;
        }

-       if (LABEL_IS_SUN) {
+       if (LABEL_IS_SGI) {

                sgi_list_table(xtra);
                return;
        }
                sgi_list_table(xtra);
                return;
        }

+       if (LABEL_IS_GPT) {
+               gpt_list_table(xtra);
+               return;
+       }

 
        list_disk_geometry();
 
 
        list_disk_geometry();
 


@@ -2029,15 +2134,15 @@ list_table(int xtra)
        if (w < 5)
                w = 5;
 
        if (w < 5)
                w = 5;
 

-       //              1 12345678901 12345678901 12345678901  12
-       printf(_("%*s Boot      Start         End      Blocks  Id System\n"),
-                  w+1, _("Device"));
+       //            1 12345678901 12345678901 12345678901  12
+       printf("%*s Boot      Start         End      Blocks  Id System\n",
+                  w+1, "Device");

 
 

-       for (i = 0; i < partitions; i++) {
+       for (i = 0; i < g_partitions; i++) {

                const struct pte *pe = &ptes[i];
                const struct pte *pe = &ptes[i];

-               off_t psects;
-               off_t pblocks;
-               unsigned int podd;
+               sector_t psects;
+               sector_t pblocks;
+               unsigned podd;

 
                p = pe->part_table;
                if (!p || is_cleared_partition(p))
 
                p = pe->part_table;
                if (!p || is_cleared_partition(p))


@@ -2054,14 +2159,14 @@ list_table(int xtra)
                if (sector_size > 1024)
                        pblocks *= (sector_size / 1024);
 
                if (sector_size > 1024)
                        pblocks *= (sector_size / 1024);
 

-               printf("%s  %c %11llu %11llu %11llu%c %2x %s\n",
+               printf("%s  %c %11"SECT_FMT"u %11"SECT_FMT"u %11"SECT_FMT"u%c %2x %s\n",

                        partname(disk_device, i+1, w+2),
                        !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */
                                ? '*' : '?',
                        partname(disk_device, i+1, w+2),
                        !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */
                                ? '*' : '?',

-                       (unsigned long long) cround(get_partition_start(pe)),           /* start */
-                       (unsigned long long) cround(get_partition_start(pe) + psects    /* end */
+                       cround(get_partition_start_from_dev_start(pe)),           /* start */
+                       cround(get_partition_start_from_dev_start(pe) + psects    /* end */

                                - (psects ? 1 : 0)),
                                - (psects ? 1 : 0)),

-                       (unsigned long long) pblocks, podd ? '+' : ' ', /* odd flag on end */
+                       pblocks, podd ? '+' : ' ', /* odd flag on end */

                        p->sys_ind,                                     /* type id */
                        partition_type(p->sys_ind));                    /* type name */
 
                        p->sys_ind,                                     /* type id */
                        partition_type(p->sys_ind));                    /* type name */
 


@@ -2069,15 +2174,15 @@ list_table(int xtra)
        }
 
        /* Is partition table in disk order? It need not be, but... */
        }
 
        /* Is partition table in disk order? It need not be, but... */

-       /* partition table entries are not checked for correct order if this
-          is a sgi, sun or aix labeled disk... */
+       /* partition table entries are not checked for correct order
+        * if this is a sgi, sun or aix labeled disk... */

        if (LABEL_IS_DOS && wrong_p_order(NULL)) {
                /* FIXME */
        if (LABEL_IS_DOS && wrong_p_order(NULL)) {
                /* FIXME */

-               printf(_("\nPartition table entries are not in disk order\n"));
+               puts("\nPartition table entries are not in disk order");

        }
 }
 
        }
 }
 

-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED

 static void
 x_list_table(int extend)
 {
 static void
 x_list_table(int extend)
 {


@@ -2085,20 +2190,21 @@ x_list_table(int extend)
        const struct partition *p;
        int i;
 
        const struct partition *p;
        int i;
 

-       printf(_("\nDisk %s: %d heads, %d sectors, %d cylinders\n\n"),
-               disk_device, heads, sectors, cylinders);
-       printf(_("Nr AF  Hd Sec  Cyl  Hd Sec  Cyl      Start       Size ID\n"));
-       for (i = 0 ; i < partitions; i++) {
+       printf("\nDisk %s: %u heads, %u sectors, %u cylinders\n\n",
+               disk_device, g_heads, g_sectors, g_cylinders);
+       puts("Nr AF  Hd Sec  Cyl  Hd Sec  Cyl      Start       Size ID");
+       for (i = 0; i < g_partitions; i++) {

                pe = &ptes[i];
                p = (extend ? pe->ext_pointer : pe->part_table);
                if (p != NULL) {
                pe = &ptes[i];
                p = (extend ? pe->ext_pointer : pe->part_table);
                if (p != NULL) {

-                       printf("%2d %02x%4d%4d%5d%4d%4d%5d%11u%11u %02x\n",
+                       printf("%2u %02x%4u%4u%5u%4u%4u%5u%11"SECT_FMT"u%11"SECT_FMT"u %02x\n",

                                i + 1, p->boot_ind, p->head,
                                sector(p->sector),
                                cylinder(p->sector, p->cyl), p->end_head,
                                sector(p->end_sector),
                                cylinder(p->end_sector, p->end_cyl),
                                i + 1, p->boot_ind, p->head,
                                sector(p->sector),
                                cylinder(p->sector, p->cyl), p->end_head,
                                sector(p->end_sector),
                                cylinder(p->end_sector, p->end_cyl),

-                               get_start_sect(p), get_nr_sects(p), p->sys_ind);
+                               get_start_sect(p), get_nr_sects(p),
+                               p->sys_ind);

                        if (p->sys_ind)
                                check_consistency(p, i);
                }
                        if (p->sys_ind)
                                check_consistency(p, i);
                }


@@ -2106,56 +2212,56 @@ x_list_table(int extend)
 }
 #endif
 
 }
 #endif
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

 static void
 static void

-fill_bounds(off_t *first, off_t *last)
+fill_bounds(sector_t *first, sector_t *last)

 {
 {

-       int i;
+       unsigned i;

        const struct pte *pe = &ptes[0];
        const struct partition *p;
 
        const struct pte *pe = &ptes[0];
        const struct partition *p;
 

-       for (i = 0; i < partitions; pe++,i++) {
+       for (i = 0; i < g_partitions; pe++,i++) {

                p = pe->part_table;
                if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) {
                        first[i] = 0xffffffff;
                        last[i] = 0;
                } else {
                p = pe->part_table;
                if (!p->sys_ind || IS_EXTENDED(p->sys_ind)) {
                        first[i] = 0xffffffff;
                        last[i] = 0;
                } else {

-                       first[i] = get_partition_start(pe);
+                       first[i] = get_partition_start_from_dev_start(pe);

                        last[i] = first[i] + get_nr_sects(p) - 1;
                }
        }
 }
 
 static void
                        last[i] = first[i] + get_nr_sects(p) - 1;
                }
        }
 }
 
 static void

-check(int n, uint h, uint s, uint c, off_t start)
+check(int n, unsigned h, unsigned s, unsigned c, sector_t start)

 {
 {

-       off_t total, real_s, real_c;
+       sector_t total, real_s, real_c;

 
        real_s = sector(s) - 1;
        real_c = cylinder(s, c);
 
        real_s = sector(s) - 1;
        real_c = cylinder(s, c);

-       total = (real_c * sectors + real_s) * heads + h;
+       total = (real_c * g_sectors + real_s) * g_heads + h;

        if (!total)
        if (!total)

-               printf(_("Warning: partition %d contains sector 0\n"), n);
-       if (h >= heads)
-               printf(_("Partition %d: head %d greater than maximum %d\n"),
-                       n, h + 1, heads);
-       if (real_s >= sectors)
-               printf(_("Partition %d: sector %d greater than "
-                       "maximum %d\n"), n, s, sectors);
-       if (real_c >= cylinders)
-               printf(_("Partitions %d: cylinder %llu greater than "
-                       "maximum %d\n"), n, (unsigned long long)real_c + 1, cylinders);
-       if (cylinders <= 1024 && start != total)
-               printf(_("Partition %d: previous sectors %llu disagrees with "
-                       "total %llu\n"), n, (unsigned long long)start, (unsigned long long)total);
+               printf("Partition %u contains sector 0\n", n);
+       if (h >= g_heads)
+               printf("Partition %u: head %u greater than maximum %u\n",
+                       n, h + 1, g_heads);
+       if (real_s >= g_sectors)
+               printf("Partition %u: sector %u greater than "
+                       "maximum %u\n", n, s, g_sectors);
+       if (real_c >= g_cylinders)
+               printf("Partition %u: cylinder %"SECT_FMT"u greater than "
+                       "maximum %u\n", n, real_c + 1, g_cylinders);
+       if (g_cylinders <= 1024 && start != total)
+               printf("Partition %u: previous sectors %"SECT_FMT"u disagrees with "
+                       "total %"SECT_FMT"u\n", n, start, total);

 }
 
 static void
 verify(void)
 {
        int i, j;
 }
 
 static void
 verify(void)
 {
        int i, j;

-       uint total = 1;
-       off_t first[partitions], last[partitions];
+       sector_t total = 1;
+       sector_t first[g_partitions], last[g_partitions];

        struct partition *p;
 
        if (warn_geometry())
        struct partition *p;
 
        if (warn_geometry())


@@ -2171,56 +2277,59 @@ verify(void)
        }
 
        fill_bounds(first, last);
        }
 
        fill_bounds(first, last);

-       for (i = 0; i < partitions; i++) {
+       for (i = 0; i < g_partitions; i++) {

                struct pte *pe = &ptes[i];
 
                p = pe->part_table;
                if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
                        check_consistency(p, i);
                struct pte *pe = &ptes[i];
 
                p = pe->part_table;
                if (p->sys_ind && !IS_EXTENDED(p->sys_ind)) {
                        check_consistency(p, i);

-                       if (get_partition_start(pe) < first[i])
-                               printf(_("Warning: bad start-of-data in "
-                                       "partition %d\n"), i + 1);
+                       if (get_partition_start_from_dev_start(pe) < first[i])
+                               printf("Warning: bad start-of-data in "
+                                       "partition %u\n", i + 1);

                        check(i + 1, p->end_head, p->end_sector, p->end_cyl,
                                last[i]);
                        total += last[i] + 1 - first[i];
                        check(i + 1, p->end_head, p->end_sector, p->end_cyl,
                                last[i]);
                        total += last[i] + 1 - first[i];

-                       for (j = 0; j < i; j++)
-                       if ((first[i] >= first[j] && first[i] <= last[j])
-                        || ((last[i] <= last[j] && last[i] >= first[j]))) {
-                               printf(_("Warning: partition %d overlaps "
-                                       "partition %d.\n"), j + 1, i + 1);
-                               total += first[i] >= first[j] ?
-                                       first[i] : first[j];
-                               total -= last[i] <= last[j] ?
-                                       last[i] : last[j];
+                       for (j = 0; j < i; j++) {
+                               if ((first[i] >= first[j] && first[i] <= last[j])
+                                || ((last[i] <= last[j] && last[i] >= first[j]))) {
+                                       printf("Warning: partition %u overlaps "
+                                               "partition %u\n", j + 1, i + 1);
+                                       total += first[i] >= first[j] ?
+                                               first[i] : first[j];
+                                       total -= last[i] <= last[j] ?
+                                               last[i] : last[j];
+                               }

                        }
                }
        }
 
        if (extended_offset) {
                struct pte *pex = &ptes[ext_index];
                        }
                }
        }
 
        if (extended_offset) {
                struct pte *pex = &ptes[ext_index];

-               off_t e_last = get_start_sect(pex->part_table) +
+               sector_t e_last = get_start_sect(pex->part_table) +

                        get_nr_sects(pex->part_table) - 1;
 
                        get_nr_sects(pex->part_table) - 1;
 

-               for (i = 4; i < partitions; i++) {
+               for (i = 4; i < g_partitions; i++) {

                        total++;
                        p = ptes[i].part_table;
                        if (!p->sys_ind) {
                        total++;
                        p = ptes[i].part_table;
                        if (!p->sys_ind) {

-                               if (i != 4 || i + 1 < partitions)
-                                       printf(_("Warning: partition %d "
-                                               "is empty\n"), i + 1);
+                               if (i != 4 || i + 1 < g_partitions)
+                                       printf("Warning: partition %u "
+                                               "is empty\n", i + 1);
+                       } else if (first[i] < extended_offset || last[i] > e_last) {
+                               printf("Logical partition %u not entirely in "
+                                       "partition %u\n", i + 1, ext_index + 1);

                        }
                        }

-                       else if (first[i] < extended_offset ||
-                                       last[i] > e_last)
-                               printf(_("Logical partition %d not entirely in "
-                                       "partition %d\n"), i + 1, ext_index + 1);

                }
        }
 
                }
        }
 

-       if (total > heads * sectors * cylinders)
-               printf(_("Total allocated sectors %d greater than the maximum "
-                       "%d\n"), total, heads * sectors * cylinders);
-       else if ((total = heads * sectors * cylinders - total) != 0)
-               printf(_("%d unallocated sectors\n"), total);
+       if (total > g_heads * g_sectors * g_cylinders)
+               printf("Total allocated sectors %u greater than the maximum "
+                       "%u\n", total, g_heads * g_sectors * g_cylinders);
+       else {
+               total = g_heads * g_sectors * g_cylinders - total;
+               if (total != 0)
+                       printf("%"SECT_FMT"u unallocated sectors\n", total);
+       }

 }
 
 static void
 }
 
 static void


@@ -2230,25 +2339,21 @@ add_partition(int n, int sys)
        int i, num_read = 0;
        struct partition *p = ptes[n].part_table;
        struct partition *q = ptes[ext_index].part_table;
        int i, num_read = 0;
        struct partition *p = ptes[n].part_table;
        struct partition *q = ptes[ext_index].part_table;

-       long long llimit;
-       off_t start, stop = 0, limit, temp,
-               first[partitions], last[partitions];
+       sector_t limit, temp;
+       sector_t start, stop = 0;
+       sector_t first[g_partitions], last[g_partitions];

 
        if (p && p->sys_ind) {
 
        if (p && p->sys_ind) {

-               printf(_("Partition %d is already defined.  Delete "
-                        "it before re-adding it.\n"), n + 1);
+               printf(msg_part_already_defined, n + 1);

                return;
        }
        fill_bounds(first, last);
        if (n < 4) {
                start = sector_offset;
                if (display_in_cyl_units || !total_number_of_sectors)
                return;
        }
        fill_bounds(first, last);
        if (n < 4) {
                start = sector_offset;
                if (display_in_cyl_units || !total_number_of_sectors)

-                       llimit = heads * sectors * cylinders - 1;
+                       limit = (sector_t) g_heads * g_sectors * g_cylinders - 1;

                else
                else

-                       llimit = total_number_of_sectors - 1;
-               limit = llimit;
-               if (limit != llimit)
-                       limit = 0x7fffffff;
+                       limit = total_number_of_sectors - 1;

                if (extended_offset) {
                        first[ext_index] = extended_offset;
                        last[ext_index] = get_start_sect(q) +
                if (extended_offset) {
                        first[ext_index] = extended_offset;
                        last[ext_index] = get_start_sect(q) +


@@ -2259,16 +2364,16 @@ add_partition(int n, int sys)
                limit = get_start_sect(q) + get_nr_sects(q) - 1;
        }
        if (display_in_cyl_units)
                limit = get_start_sect(q) + get_nr_sects(q) - 1;
        }
        if (display_in_cyl_units)

-               for (i = 0; i < partitions; i++)
+               for (i = 0; i < g_partitions; i++)

                        first[i] = (cround(first[i]) - 1) * units_per_sector;
 
                        first[i] = (cround(first[i]) - 1) * units_per_sector;
 

-       snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
+       snprintf(mesg, sizeof(mesg), "First %s", str_units(SINGULAR));

        do {
                temp = start;
        do {
                temp = start;

-               for (i = 0; i < partitions; i++) {
+               for (i = 0; i < g_partitions; i++) {

                        int lastplusoff;
 
                        int lastplusoff;
 

-                       if (start == ptes[i].offset)
+                       if (start == ptes[i].offset_from_dev_start)

                                start += sector_offset;
                        lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
                        if (start >= first[i] && start <= lastplusoff)
                                start += sector_offset;
                        lastplusoff = last[i] + ((n < 4) ? 0 : sector_offset);
                        if (start >= first[i] && start <= lastplusoff)


@@ -2277,19 +2382,19 @@ add_partition(int n, int sys)
                if (start > limit)
                        break;
                if (start >= temp+units_per_sector && num_read) {
                if (start > limit)
                        break;
                if (start >= temp+units_per_sector && num_read) {

-                       printf(_("Sector %"OFF_FMT" is already allocated\n"), temp);
+                       printf("Sector %"SECT_FMT"u is already allocated\n", temp);

                        temp = start;
                        num_read = 0;
                }
                if (!num_read && start == temp) {
                        temp = start;
                        num_read = 0;
                }
                if (!num_read && start == temp) {

-                       off_t saved_start;
+                       sector_t saved_start;

 
                        saved_start = start;
 
                        saved_start = start;

-                       start = read_int(cround(saved_start), cround(saved_start), cround(limit),
-                                        0, mesg);
+                       start = read_int(cround(saved_start), cround(saved_start), cround(limit), 0, mesg);

                        if (display_in_cyl_units) {
                                start = (start - 1) * units_per_sector;
                        if (display_in_cyl_units) {
                                start = (start - 1) * units_per_sector;

-                               if (start < saved_start) start = saved_start;
+                               if (start < saved_start)
+                                       start = saved_start;

                        }
                        num_read = 1;
                }
                        }
                        num_read = 1;
                }


@@ -2297,36 +2402,35 @@ add_partition(int n, int sys)
        if (n > 4) {                    /* NOT for fifth partition */
                struct pte *pe = &ptes[n];
 
        if (n > 4) {                    /* NOT for fifth partition */
                struct pte *pe = &ptes[n];
 

-               pe->offset = start - sector_offset;
-               if (pe->offset == extended_offset) { /* must be corrected */
-                       pe->offset++;
+               pe->offset_from_dev_start = start - sector_offset;
+               if (pe->offset_from_dev_start == extended_offset) { /* must be corrected */
+                       pe->offset_from_dev_start++;

                        if (sector_offset == 1)
                                start++;
                }
        }
 
                        if (sector_offset == 1)
                                start++;
                }
        }
 

-       for (i = 0; i < partitions; i++) {
+       for (i = 0; i < g_partitions; i++) {

                struct pte *pe = &ptes[i];
 
                struct pte *pe = &ptes[i];
 

-               if (start < pe->offset && limit >= pe->offset)
-                       limit = pe->offset - 1;
+               if (start < pe->offset_from_dev_start && limit >= pe->offset_from_dev_start)
+                       limit = pe->offset_from_dev_start - 1;

                if (start < first[i] && limit >= first[i])
                        limit = first[i] - 1;
        }
        if (start > limit) {
                if (start < first[i] && limit >= first[i])
                        limit = first[i] - 1;
        }
        if (start > limit) {

-               printf(_("No free sectors available\n"));
+               puts("No free sectors available");

                if (n > 4)
                if (n > 4)

-                       partitions--;
+                       g_partitions--;

                return;
        }
        if (cround(start) == cround(limit)) {
                stop = limit;
        } else {
                snprintf(mesg, sizeof(mesg),
                return;
        }
        if (cround(start) == cround(limit)) {
                stop = limit;
        } else {
                snprintf(mesg, sizeof(mesg),

-                        _("Last %s or +size or +sizeM or +sizeK"),
+                        "Last %s or +size or +sizeM or +sizeK",

                         str_units(SINGULAR));
                         str_units(SINGULAR));

-               stop = read_int(cround(start), cround(limit), cround(limit),
-                               cround(start), mesg);
+               stop = read_int(cround(start), cround(limit), cround(limit), cround(start), mesg);

                if (display_in_cyl_units) {
                        stop = stop * units_per_sector - 1;
                        if (stop >limit)
                if (display_in_cyl_units) {
                        stop = stop * units_per_sector - 1;
                        if (stop >limit)


@@ -2336,7 +2440,7 @@ add_partition(int n, int sys)
 
        set_partition(n, 0, start, stop, sys);
        if (n > 4)
 
        set_partition(n, 0, start, stop, sys);
        if (n > 4)

-               set_partition(n - 1, 1, ptes[n].offset, stop, EXTENDED);
+               set_partition(n - 1, 1, ptes[n].offset_from_dev_start, stop, EXTENDED);

 
        if (IS_EXTENDED(sys)) {
                struct pte *pe4 = &ptes[4];
 
        if (IS_EXTENDED(sys)) {
                struct pte *pe4 = &ptes[4];


@@ -2344,29 +2448,29 @@ add_partition(int n, int sys)
 
                ext_index = n;
                pen->ext_pointer = p;
 
                ext_index = n;
                pen->ext_pointer = p;

-               pe4->offset = extended_offset = start;
+               pe4->offset_from_dev_start = extended_offset = start;

                pe4->sectorbuffer = xzalloc(sector_size);
                pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
                pe4->ext_pointer = pe4->part_table + 1;
                pe4->changed = 1;
                pe4->sectorbuffer = xzalloc(sector_size);
                pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
                pe4->ext_pointer = pe4->part_table + 1;
                pe4->changed = 1;

-               partitions = 5;
+               g_partitions = 5;

        }
 }
 
 static void
 add_logical(void)
 {
        }
 }
 
 static void
 add_logical(void)
 {

-       if (partitions > 5 || ptes[4].part_table->sys_ind) {
-               struct pte *pe = &ptes[partitions];
+       if (g_partitions > 5 || ptes[4].part_table->sys_ind) {
+               struct pte *pe = &ptes[g_partitions];

 
                pe->sectorbuffer = xzalloc(sector_size);
                pe->part_table = pt_offset(pe->sectorbuffer, 0);
                pe->ext_pointer = pe->part_table + 1;
 
                pe->sectorbuffer = xzalloc(sector_size);
                pe->part_table = pt_offset(pe->sectorbuffer, 0);
                pe->ext_pointer = pe->part_table + 1;

-               pe->offset = 0;
+               pe->offset_from_dev_start = 0;

                pe->changed = 1;
                pe->changed = 1;

-               partitions++;
+               g_partitions++;

        }
        }

-       add_partition(partitions - 1, LINUX_NATIVE);
+       add_partition(g_partitions - 1, LINUX_NATIVE);

 }
 
 static void
 }
 
 static void


@@ -2378,27 +2482,25 @@ new_partition(void)
                return;
 
        if (LABEL_IS_SUN) {
                return;
 
        if (LABEL_IS_SUN) {

-               add_sun_partition(get_partition(0, partitions), LINUX_NATIVE);
+               add_sun_partition(get_partition(0, g_partitions), LINUX_NATIVE);

                return;
        }
        if (LABEL_IS_SGI) {
                return;
        }
        if (LABEL_IS_SGI) {

-               sgi_add_partition(get_partition(0, partitions), LINUX_NATIVE);
+               sgi_add_partition(get_partition(0, g_partitions), LINUX_NATIVE);

                return;
        }
        if (LABEL_IS_AIX) {
                return;
        }
        if (LABEL_IS_AIX) {

-               printf(_("\tSorry - this fdisk cannot handle AIX disk labels."
-                        "\n\tIf you want to add DOS-type partitions, create"
-                        "\n\ta new empty DOS partition table first. (Use o.)"
-                        "\n\tWARNING: "
-                        "This will destroy the present disk contents.\n"));
+               puts("Sorry - this fdisk cannot handle AIX disk labels.\n"
+"If you want to add DOS-type partitions, create a new empty DOS partition\n"
+"table first (use 'o'). This will destroy the present disk contents.");

                return;
        }
 
        for (i = 0; i < 4; i++)
                free_primary += !ptes[i].part_table->sys_ind;
 
                return;
        }
 
        for (i = 0; i < 4; i++)
                free_primary += !ptes[i].part_table->sys_ind;
 

-       if (!free_primary && partitions >= MAXIMUM_PARTS) {
-               printf(_("The maximum number of partitions has been created\n"));
+       if (!free_primary && g_partitions >= MAXIMUM_PARTS) {
+               puts("The maximum number of partitions has been created");

                return;
        }
 
                return;
        }
 


@@ -2406,39 +2508,69 @@ new_partition(void)
                if (extended_offset)
                        add_logical();
                else
                if (extended_offset)
                        add_logical();
                else

-                       printf(_("You must delete some partition and add "
-                                "an extended partition first\n"));
+                       puts("You must delete some partition and add "
+                                "an extended partition first");

        } else {
        } else {

-               char c, line[LINE_LENGTH];
-               snprintf(line, sizeof(line), "%s\n   %s\n   p   primary "
-                                               "partition (1-4)\n",
-                        "Command action", (extended_offset ?
-                        "l   logical (5 or over)" : "e   extended"));
+               char c, line[80];
+               snprintf(line, sizeof(line),
+                       "Command action\n"
+                       "   %s\n"
+                       "   p   primary partition (1-4)\n",
+                       (extended_offset ?
+                       "l   logical (5 or over)" : "e   extended"));

                while (1) {
                        c = read_nonempty(line);
                while (1) {
                        c = read_nonempty(line);

-                       if (c == 'p' || c == 'P') {
+                       if ((c | 0x20) == 'p') {

                                i = get_nonexisting_partition(0, 4);
                                if (i >= 0)
                                        add_partition(i, LINUX_NATIVE);
                                return;
                        }
                                i = get_nonexisting_partition(0, 4);
                                if (i >= 0)
                                        add_partition(i, LINUX_NATIVE);
                                return;
                        }

-                       else if (c == 'l' && extended_offset) {
+                       if (c == 'l' && extended_offset) {

                                add_logical();
                                return;
                        }
                                add_logical();
                                return;
                        }

-                       else if (c == 'e' && !extended_offset) {
+                       if (c == 'e' && !extended_offset) {

                                i = get_nonexisting_partition(0, 4);
                                if (i >= 0)
                                        add_partition(i, EXTENDED);
                                return;
                        }
                                i = get_nonexisting_partition(0, 4);
                                if (i >= 0)
                                        add_partition(i, EXTENDED);
                                return;
                        }

-                       else
-                               printf(_("Invalid partition number "
-                                        "for type `%c'\n"), c);
+                       printf("Invalid partition number "
+                                        "for type '%c'\n", c);

                }
        }
 }
 
                }
        }
 }
 

+static void
+reread_partition_table(int leave)
+{
+       int i;
+
+       puts("Calling ioctl() to re-read partition table");
+       sync();
+       /* Users with slow external USB disks on a 320MHz ARM system (year 2011)
+        * report that sleep is needed, otherwise BLKRRPART may fail with -EIO:
+        */
+       sleep(1);
+       i = ioctl_or_perror(dev_fd, BLKRRPART, NULL,
+                       "WARNING: rereading partition table "
+                       "failed, kernel still uses old table");
+#if 0
+       if (dos_changed)
+               puts(
+               "\nWARNING: If you have created or modified any DOS 6.x\n"
+               "partitions, please see the fdisk manual page for additional\n"
+               "information");
+#endif
+
+       if (leave) {
+               if (ENABLE_FEATURE_CLEAN_UP)
+                       close_dev_fd();
+               exit(i != 0);
+       }
+}
+

 static void
 write_table(void)
 {
 static void
 write_table(void)
 {


@@ -2448,81 +2580,33 @@ write_table(void)
                for (i = 0; i < 3; i++)
                        if (ptes[i].changed)
                                ptes[3].changed = 1;
                for (i = 0; i < 3; i++)
                        if (ptes[i].changed)
                                ptes[3].changed = 1;

-               for (i = 3; i < partitions; i++) {
+               for (i = 3; i < g_partitions; i++) {

                        struct pte *pe = &ptes[i];
                        struct pte *pe = &ptes[i];

-

                        if (pe->changed) {
                                write_part_table_flag(pe->sectorbuffer);
                        if (pe->changed) {
                                write_part_table_flag(pe->sectorbuffer);

-                               write_sector(pe->offset, pe->sectorbuffer);
+                               write_sector(pe->offset_from_dev_start, pe->sectorbuffer);

                        }
                }
        }
        else if (LABEL_IS_SGI) {
                        }
                }
        }
        else if (LABEL_IS_SGI) {

-               /* no test on change? the printf below might be mistaken */
+               /* no test on change? the "altered" msg below might be mistaken */

                sgi_write_table();
        }
        else if (LABEL_IS_SUN) {
                sgi_write_table();
        }
        else if (LABEL_IS_SUN) {

-               int needw = 0;
-
-               for (i = 0; i < 8; i++)
-                       if (ptes[i].changed)
-                               needw = 1;
-               if (needw)
-                       sun_write_table();
+               for (i = 0; i < 8; i++) {
+                       if (ptes[i].changed) {
+                               sun_write_table();
+                               break;
+                       }
+               }

        }
 
        }
 

-       printf(_("The partition table has been altered!\n\n"));
+       puts("The partition table has been altered.");

        reread_partition_table(1);
 }
        reread_partition_table(1);
 }

+#endif /* FEATURE_FDISK_WRITABLE */

 
 

-static void
-reread_partition_table(int leave)
-{
-       int error = 0;
-       int i;
-
-       printf(_("Calling ioctl() to re-read partition table.\n"));
-       sync();
-       sleep(2);
-       if ((i = ioctl(fd, BLKRRPART)) != 0) {
-               error = errno;
-       } else {
-               /* some kernel versions (1.2.x) seem to have trouble
-                  rereading the partition table, but if asked to do it
-                  twice, the second time works. - biro@yggdrasil.com */
-               sync();
-               sleep(2);
-               if ((i = ioctl(fd, BLKRRPART)) != 0)
-                       error = errno;
-       }
-
-       if (i) {
-               printf(_("\nWARNING: Re-reading the partition table "
-                        "failed with error %d: %s.\n"
-                        "The kernel still uses the old table.\n"
-                        "The new table will be used "
-                        "at the next reboot.\n"),
-                       error, strerror(error));
-       }
-
-       if (dos_changed)
-               printf(
-               _("\nWARNING: If you have created or modified any DOS 6.x\n"
-               "partitions, please see the fdisk manual page for additional\n"
-               "information.\n"));
-
-       if (leave) {
-               close(fd);
-
-               printf(_("Syncing disks.\n"));
-               sync();
-               sleep(4);               /* for sync() */
-               exit(!!i);
-       }
-}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED

 #define MAX_PER_LINE    16
 static void
 print_buffer(char *pbuffer)
 #define MAX_PER_LINE    16
 static void
 print_buffer(char *pbuffer)


@@ -2534,51 +2618,53 @@ print_buffer(char *pbuffer)
                        printf("0x%03X:", i);
                printf(" %02X", (unsigned char) pbuffer[i]);
                if (l == MAX_PER_LINE - 1) {
                        printf("0x%03X:", i);
                printf(" %02X", (unsigned char) pbuffer[i]);
                if (l == MAX_PER_LINE - 1) {

-                       puts("");
+                       bb_putchar('\n');

                        l = -1;
                }
        }
        if (l > 0)
                        l = -1;
                }
        }
        if (l > 0)

-               puts("");
-       puts("");
+               bb_putchar('\n');
+       bb_putchar('\n');

 }
 
 }
 

-

 static void
 print_raw(void)
 {
        int i;
 
 static void
 print_raw(void)
 {
        int i;
 

-       printf(_("Device: %s\n"), disk_device);
+       printf("Device: %s\n", disk_device);

        if (LABEL_IS_SGI || LABEL_IS_SUN)
                print_buffer(MBRbuffer);
        else {
        if (LABEL_IS_SGI || LABEL_IS_SUN)
                print_buffer(MBRbuffer);
        else {

-               for (i = 3; i < partitions; i++)
+               for (i = 3; i < g_partitions; i++)

                        print_buffer(ptes[i].sectorbuffer);
        }
 }
 
 static void
                        print_buffer(ptes[i].sectorbuffer);
        }
 }
 
 static void

-move_begin(int i)
+move_begin(unsigned i)

 {
        struct pte *pe = &ptes[i];
        struct partition *p = pe->part_table;
 {
        struct pte *pe = &ptes[i];
        struct partition *p = pe->part_table;

-       off_t new, first;
+       sector_t new, first, nr_sects;

 
        if (warn_geometry())
                return;
 
        if (warn_geometry())
                return;

-       if (!p->sys_ind || !get_nr_sects(p) || IS_EXTENDED(p->sys_ind)) {
-               printf(_("Partition %d has no data area\n"), i + 1);
+       nr_sects = get_nr_sects(p);
+       if (!p->sys_ind || !nr_sects || IS_EXTENDED(p->sys_ind)) {
+               printf("Partition %u has no data area\n", i + 1);

                return;
        }
                return;
        }

-       first = get_partition_start(pe);
-       new = read_int(first, first, first + get_nr_sects(p) - 1, first,
-                          _("New beginning of data")) - pe->offset;
-
-       if (new != get_nr_sects(p)) {
-               first = get_nr_sects(p) + get_start_sect(p) - new;
-               set_nr_sects(p, first);
-               set_start_sect(p, new);
+       first = get_partition_start_from_dev_start(pe); /* == pe->offset_from_dev_start + get_start_sect(p) */
+       new = read_int(0 /*was:first*/, first, first + nr_sects - 1, first, "New beginning of data");
+       if (new != first) {
+               sector_t new_relative = new - pe->offset_from_dev_start;
+               nr_sects += (get_start_sect(p) - new_relative);
+               set_start_sect(p, new_relative);
+               set_nr_sects(p, nr_sects);
+               read_nonempty("Recalculate C/H/S values? (Y/N): ");
+               if ((line_ptr[0] | 0x20) == 'y')
+                       set_hsc_start_end(p, new, new + nr_sects - 1);

                pe->changed = 1;
        }
 }
                pe->changed = 1;
        }
 }


@@ -2589,8 +2675,8 @@ xselect(void)
        char c;
 
        while (1) {
        char c;
 
        while (1) {

-               putchar('\n');
-               c = tolower(read_nonempty(_("Expert command (m for help): ")));
+               bb_putchar('\n');
+               c = 0x20 | read_nonempty("Expert command (m for help): ");

                switch (c) {
                case 'a':
                        if (LABEL_IS_SUN)
                switch (c) {
                case 'a':
                        if (LABEL_IS_SUN)


@@ -2598,14 +2684,14 @@ xselect(void)
                        break;
                case 'b':
                        if (LABEL_IS_DOS)
                        break;
                case 'b':
                        if (LABEL_IS_DOS)

-                               move_begin(get_partition(0, partitions));
+                               move_begin(get_partition(0, g_partitions));

                        break;
                case 'c':
                        break;
                case 'c':

-                       user_cylinders = cylinders =
-                               read_int(1, cylinders, 1048576, 0,
-                                       _("Number of cylinders"));
+                       user_cylinders = g_cylinders =
+                               read_int(1, g_cylinders, 1048576, 0,
+                                       "Number of cylinders");

                        if (LABEL_IS_SUN)
                        if (LABEL_IS_SUN)

-                               sun_set_ncyl(cylinders);
+                               sun_set_ncyl(g_cylinders);

                        if (LABEL_IS_DOS)
                                warn_cylinders();
                        break;
                        if (LABEL_IS_DOS)
                                warn_cylinders();
                        break;


@@ -2625,13 +2711,12 @@ xselect(void)
                                fix_partition_table_order();
                        break;
                case 'g':
                                fix_partition_table_order();
                        break;
                case 'g':

-#ifdef CONFIG_FEATURE_SGI_LABEL
+#if ENABLE_FEATURE_SGI_LABEL

                        create_sgilabel();
 #endif
                        break;
                case 'h':
                        create_sgilabel();
 #endif
                        break;
                case 'h':

-                       user_heads = heads = read_int(1, heads, 256, 0,
-                                       _("Number of heads"));
+                       user_heads = g_heads = read_int(1, g_heads, 256, 0, "Number of heads");

                        update_units();
                        break;
                case 'i':
                        update_units();
                        break;
                case 'i':


@@ -2649,18 +2734,18 @@ xselect(void)
                                x_list_table(0);
                        break;
                case 'q':
                                x_list_table(0);
                        break;
                case 'q':

-                       close(fd);
-                       puts("");
-                       exit(0);
+                       if (ENABLE_FEATURE_CLEAN_UP)
+                               close_dev_fd();
+                       bb_putchar('\n');
+                       exit(EXIT_SUCCESS);

                case 'r':
                        return;
                case 's':
                case 'r':
                        return;
                case 's':

-                       user_sectors = sectors = read_int(1, sectors, 63, 0,
-                                          _("Number of sectors"));
+                       user_sectors = g_sectors = read_int(1, g_sectors, 63, 0, "Number of sectors");

                        if (dos_compatible_flag) {
                        if (dos_compatible_flag) {

-                               sector_offset = sectors;
-                               printf(_("Warning: setting sector offset for DOS "
-                                       "compatiblity\n"));
+                               sector_offset = g_sectors;
+                               puts("Warning: setting sector offset for DOS "
+                                       "compatiblity");

                        }
                        update_units();
                        break;
                        }
                        update_units();
                        break;


@@ -2696,14 +2781,14 @@ is_ide_cdrom_or_tape(const char *device)
           the process hangs on the attempt to read a music CD.
           So try to be careful. This only works since 2.1.73. */
 
           the process hangs on the attempt to read a music CD.
           So try to be careful. This only works since 2.1.73. */
 

-       if (strncmp("/dev/hd", device, 7))
+       if (!is_prefixed_with(device, "/dev/hd"))

                return 0;
 
        snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);
                return 0;
 
        snprintf(buf, sizeof(buf), "/proc/ide/%s/media", device+5);

-       procf = fopen(buf, "r");
+       procf = fopen_for_read(buf);

        if (procf != NULL && fgets(buf, sizeof(buf), procf))
        if (procf != NULL && fgets(buf, sizeof(buf), procf))

-               is_ide = (!strncmp(buf, "cdrom", 5) ||
-                         !strncmp(buf, "tape", 4));
+               is_ide = (is_prefixed_with(buf, "cdrom") ||
+                         is_prefixed_with(buf, "tape"));

        else
                /* Now when this proc file does not exist, skip the
                   device when it is read-only. */
        else
                /* Now when this proc file does not exist, skip the
                   device when it is read-only. */


@@ -2717,7 +2802,7 @@ is_ide_cdrom_or_tape(const char *device)
 
 
 static void
 
 
 static void

-try(const char *device, int user_specified)
+open_list_and_close(const char *device, int user_specified)

 {
        int gb;
 
 {
        int gb;
 


@@ -2727,260 +2812,235 @@ try(const char *device, int user_specified)
        if (!user_specified)
                if (is_ide_cdrom_or_tape(device))
                        return;
        if (!user_specified)
                if (is_ide_cdrom_or_tape(device))
                        return;

-       if ((fd = open(disk_device, type_open)) >= 0) {
-               gb = get_boot(try_only);
-               if (gb > 0) {   /* I/O error */
-                       close(fd);
-               } else if (gb < 0) { /* no DOS signature */
-                       list_disk_geometry();
-                       if (LABEL_IS_AIX) {
-                               return;
-                       }
-#ifdef CONFIG_FEATURE_OSF_LABEL
-                       if (btrydev(device) < 0)
-#endif
-                               printf(_("Disk %s doesn't contain a valid "
-                                       "partition table\n"), device);
-                       close(fd);
-               } else {
-                       close(fd);
-                       list_table(0);
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-                       if (!LABEL_IS_SUN && partitions > 4){
-                               delete_partition(ext_index);
-                       }
-#endif
-               }
-       } else {
+
+       /* Open disk_device, save file descriptor to dev_fd */
+       errno = 0;
+       gb = get_boot(TRY_ONLY);
+       if (gb > 0) {   /* I/O error */

                /* Ignore other errors, since we try IDE
                   and SCSI hard disks which may not be
                   installed on the system. */
                /* Ignore other errors, since we try IDE
                   and SCSI hard disks which may not be
                   installed on the system. */

-               if (errno == EACCES) {
-                       printf(_("Cannot open %s\n"), device);
-                       return;
+               if (user_specified || errno == EACCES)
+                       bb_perror_msg("can't open '%s'", device);
+               return;
+       }
+
+       if (gb < 0) { /* no DOS signature */
+               list_disk_geometry();
+               if (LABEL_IS_AIX)
+                       goto ret;
+#if ENABLE_FEATURE_OSF_LABEL
+               if (bsd_trydev(device) < 0)
+#endif
+                       printf("Disk %s doesn't contain a valid "
+                               "partition table\n", device);
+       } else {
+               list_table(0);
+#if ENABLE_FEATURE_FDISK_WRITABLE
+               if (!LABEL_IS_SUN && g_partitions > 4) {
+                       delete_partition(ext_index);

                }
                }

+#endif

        }
        }

+ ret:
+       close_dev_fd();
+}
+
+/* Is it a whole disk? The digit check is still useful
+   for Xen devices for example. */
+static int is_whole_disk(const char *disk)
+{
+       unsigned len;
+       int fd = open(disk, O_RDONLY);
+
+       if (fd != -1) {
+               struct hd_geometry geometry;
+               int err = ioctl(fd, HDIO_GETGEO, &geometry);
+               close(fd);
+               if (!err)
+                       return (geometry.start == 0);
+       }
+
+       /* Treat "nameN" as a partition name, not whole disk */
+       /* note: mmcblk0 should work from the geometry check above */
+       len = strlen(disk);
+       if (len != 0 && isdigit(disk[len - 1]))
+               return 0;
+
+       return 1;

 }
 
 /* for fdisk -l: try all things in /proc/partitions
    that look like a partition name (do not end in a digit) */
 static void
 }
 
 /* for fdisk -l: try all things in /proc/partitions
    that look like a partition name (do not end in a digit) */
 static void

-tryprocpt(void)
+list_devs_in_proc_partititons(void)

 {
        FILE *procpt;
 {
        FILE *procpt;

-       char line[100], ptname[100], devname[120], *s;
+       char line[100], ptname[100], devname[120];

        int ma, mi, sz;
 
        procpt = fopen_or_warn("/proc/partitions", "r");
 
        while (fgets(line, sizeof(line), procpt)) {
        int ma, mi, sz;
 
        procpt = fopen_or_warn("/proc/partitions", "r");
 
        while (fgets(line, sizeof(line), procpt)) {

-               if (sscanf(line, " %d %d %d %[^\n ]",
+               if (sscanf(line, " %u %u %u %[^\n ]",

                                &ma, &mi, &sz, ptname) != 4)
                        continue;
                                &ma, &mi, &sz, ptname) != 4)
                        continue;

-               for (s = ptname; *s; s++);
-               if (isdigit(s[-1]))
-                       continue;
+

                sprintf(devname, "/dev/%s", ptname);
                sprintf(devname, "/dev/%s", ptname);

-               try(devname, 0);
+               if (is_whole_disk(devname))
+                       open_list_and_close(devname, 0);

        }
        }

-#ifdef CONFIG_FEATURE_CLEAN_UP
+#if ENABLE_FEATURE_CLEAN_UP

        fclose(procpt);
 #endif
 }
 
        fclose(procpt);
 #endif
 }
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

 static void
 unknown_command(int c)
 {
 static void
 unknown_command(int c)
 {

-       printf(_("%c: unknown command\n"), c);
+       printf("%c: unknown command\n", c);

 }
 #endif
 
 }
 #endif
 

-int fdisk_main(int argc, char **argv)
+int fdisk_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int fdisk_main(int argc UNUSED_PARAM, char **argv)

 {
 {

-       int c;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-       int optl = 0;
-#endif
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
-       int opts = 0;
-#endif
+       unsigned opt;

        /*
        /*

-        * Calls:

         *  fdisk -v
         *  fdisk -l [-b sectorsize] [-u] device ...
         *  fdisk -s [partition] ...
         *  fdisk [-b sectorsize] [-u] device
         *
         * Options -C, -H, -S set the geometry.
         *  fdisk -v
         *  fdisk -l [-b sectorsize] [-u] device ...
         *  fdisk -s [partition] ...
         *  fdisk [-b sectorsize] [-u] device
         *
         * Options -C, -H, -S set the geometry.

-        *

         */
         */

-       while ((c = getopt(argc, argv, "b:C:H:lS:u"
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
-                                       "s"
-#endif
-                                       )) != -1) {
-               switch (c) {
-               case 'b':
-                       /* Ugly: this sector size is really per device,
-                          so cannot be combined with multiple disks,
-                          and te same goes for the C/H/S options.
-                       */
-                       sector_size = xatoi_u(optarg);
-                       if (sector_size != 512 && sector_size != 1024 &&
-                               sector_size != 2048)
-                               bb_show_usage();
-                       sector_offset = 2;
-                       user_set_sector_size = 1;
-                       break;
-               case 'C':
-                       user_cylinders = xatoi_u(optarg);
-                       break;
-               case 'H':
-                       user_heads = xatoi_u(optarg);
-                       if (user_heads <= 0 || user_heads >= 256)
-                               user_heads = 0;
-                       break;
-               case 'S':
-                       user_sectors = xatoi_u(optarg);
-                       if (user_sectors <= 0 || user_sectors >= 64)
-                               user_sectors = 0;
-                       break;
-               case 'l':
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-                       optl = 1;
-#endif
-                       break;
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
-               case 's':
-                       opts = 1;
-                       break;
-#endif
-               case 'u':
-                       display_in_cyl_units = 0;
-                       break;
-               default:
+       INIT_G();
+
+       close_dev_fd(); /* needed: fd 3 must not stay closed */
+
+       opt = getopt32(argv, "b:+C:+H:+lS:+u" IF_FEATURE_FDISK_BLKSIZE("s"),
+                               &sector_size, &user_cylinders, &user_heads, &user_sectors);
+       argv += optind;
+       if (opt & OPT_b) {
+               /* Ugly: this sector size is really per device,
+                * so cannot be combined with multiple disks,
+                * and the same goes for the C/H/S options.
+                */
+               if (sector_size < 512
+                || sector_size > 0x10000
+                || (sector_size & (sector_size-1)) /* not power of 2 */
+               ) {

                        bb_show_usage();
                }
                        bb_show_usage();
                }

-       }
-
-       if (user_set_sector_size && argc-optind != 1)
-               printf(_("Warning: the -b (set sector size) option should"
-                        " be used with one specified device\n"));
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-       if (optl) {
+               sector_offset = 2;
+               user_set_sector_size = 1;
+       }
+       if (user_heads <= 0 || user_heads >= 256)
+               user_heads = 0;
+       if (user_sectors <= 0 || user_sectors >= 64)
+               user_sectors = 0;
+       if (opt & OPT_u)
+               display_in_cyl_units = 0; // -u
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
+       if (opt & OPT_l) {

                nowarn = 1;
 #endif
                nowarn = 1;
 #endif

-               type_open = O_RDONLY;
-               if (argc > optind) {
-                       int k;
-#if __GNUC__
-                       /* avoid gcc warning:
-                          variable `k' might be clobbered by `longjmp' */
-                       (void)&k;
-#endif
+               if (*argv) {

                        listing = 1;
                        listing = 1;

-                       for (k = optind; k < argc; k++)
-                               try(argv[k], 1);
+                       do {
+                               open_list_and_close(*argv, 1);
+                       } while (*++argv);

                } else {
                } else {

-                       /* we no longer have default device names */
-                       /* but, we can use /proc/partitions instead */
-                       tryprocpt();
+                       /* we don't have device names, */
+                       /* use /proc/partitions instead */
+                       list_devs_in_proc_partititons();

                }
                return 0;
                }
                return 0;

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE

        }
 #endif
 
        }
 #endif
 

-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
-       if (opts) {
-               long size;
+#if ENABLE_FEATURE_FDISK_BLKSIZE
+       if (opt & OPT_s) {

                int j;
 
                nowarn = 1;
                int j;
 
                nowarn = 1;

-               type_open = O_RDONLY;
-
-               opts = argc - optind;
-               if (opts <= 0)
+               if (!argv[0])

                        bb_show_usage();
                        bb_show_usage();

-
-               for (j = optind; j < argc; j++) {
-                       disk_device = argv[j];
-                       if ((fd = open(disk_device, type_open)) < 0)
-                               fdisk_fatal(unable_to_open);
-                       if (ioctl(fd, BLKGETSIZE, &size))
-                               fdisk_fatal(ioctl_error);
+               for (j = 0; argv[j]; j++) {
+                       unsigned long long size;
+                       fd = xopen(argv[j], O_RDONLY);
+                       size = bb_BLKGETSIZE_sectors(fd) / 2;

                        close(fd);
                        close(fd);

-                       if (opts == 1)
-                               printf("%ld\n", size/2);
+                       if (argv[1])
+                               printf("%llu\n", size);

                        else
                        else

-                               printf("%s: %ld\n", argv[j], size/2);
+                               printf("%s: %llu\n", argv[j], size);

                }
                return 0;
        }
 #endif
 
                }
                return 0;
        }
 #endif
 

-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-       if (argc-optind == 1)
-               disk_device = argv[optind];
-       else
+#if ENABLE_FEATURE_FDISK_WRITABLE
+       if (!argv[0] || argv[1])

                bb_show_usage();
 
                bb_show_usage();
 

-       get_boot(fdisk);
+       disk_device = argv[0];
+       get_boot(OPEN_MAIN);

 
        if (LABEL_IS_OSF) {
                /* OSF label, and no DOS label */
 
        if (LABEL_IS_OSF) {
                /* OSF label, and no DOS label */

-               printf(_("Detected an OSF/1 disklabel on %s, entering "
-                       "disklabel mode.\n"), disk_device);
+               printf("Detected an OSF/1 disklabel on %s, entering "
+                       "disklabel mode\n", disk_device);

                bsd_select();
                /*Why do we do this?  It seems to be counter-intuitive*/
                bsd_select();
                /*Why do we do this?  It seems to be counter-intuitive*/

-               current_label_type = label_dos;
+               current_label_type = LABEL_DOS;

                /* If we return we may want to make an empty DOS label? */
        }
 
        while (1) {
                /* If we return we may want to make an empty DOS label? */
        }
 
        while (1) {

-               putchar('\n');
-               c = tolower(read_nonempty(_("Command (m for help): ")));
+               int c;
+               bb_putchar('\n');
+               c = 0x20 | read_nonempty("Command (m for help): ");

                switch (c) {
                case 'a':
                        if (LABEL_IS_DOS)
                switch (c) {
                case 'a':
                        if (LABEL_IS_DOS)

-                               toggle_active(get_partition(1, partitions));
+                               toggle_active(get_partition(1, g_partitions));

                        else if (LABEL_IS_SUN)
                        else if (LABEL_IS_SUN)

-                               toggle_sunflags(get_partition(1, partitions),
+                               toggle_sunflags(get_partition(1, g_partitions),

                                                0x01);
                        else if (LABEL_IS_SGI)
                                sgi_set_bootpartition(
                                                0x01);
                        else if (LABEL_IS_SGI)
                                sgi_set_bootpartition(

-                                       get_partition(1, partitions));
+                                       get_partition(1, g_partitions));

                        else
                                unknown_command(c);
                        break;
                case 'b':
                        if (LABEL_IS_SGI) {
                        else
                                unknown_command(c);
                        break;
                case 'b':
                        if (LABEL_IS_SGI) {

-                               printf(_("\nThe current boot file is: %s\n"),
+                               printf("\nThe current boot file is: %s\n",

                                        sgi_get_bootfile());
                                        sgi_get_bootfile());

-                               if (read_maybe_empty(_("Please enter the name of the "
-                                                  "new boot file: ")) == '\n')
-                                       printf(_("Boot file unchanged\n"));
+                               if (read_maybe_empty("Please enter the name of the "
+                                               "new boot file: ") == '\n')
+                                       puts("Boot file unchanged");

                                else
                                        sgi_set_bootfile(line_ptr);
                                else
                                        sgi_set_bootfile(line_ptr);

-                       } else
-#ifdef CONFIG_FEATURE_OSF_LABEL
+                       }
+#if ENABLE_FEATURE_OSF_LABEL
+                       else

                                bsd_select();
 #endif
                                bsd_select();
 #endif

-
-/* BUG!? Think what will happen if !CONFIG_FEATURE_OSF_LABEL !!! */
-

                        break;
                case 'c':
                        if (LABEL_IS_DOS)
                                toggle_dos_compatibility_flag();
                        else if (LABEL_IS_SUN)
                        break;
                case 'c':
                        if (LABEL_IS_DOS)
                                toggle_dos_compatibility_flag();
                        else if (LABEL_IS_SUN)

-                               toggle_sunflags(get_partition(1, partitions),
+                               toggle_sunflags(get_partition(1, g_partitions),

                                                0x10);
                        else if (LABEL_IS_SGI)
                                sgi_set_swappartition(
                                                0x10);
                        else if (LABEL_IS_SGI)
                                sgi_set_swappartition(

-                                               get_partition(1, partitions));
+                                               get_partition(1, g_partitions));

                        else
                                unknown_command(c);
                        break;
                        else
                                unknown_command(c);
                        break;


@@ -2992,9 +3052,9 @@ int fdisk_main(int argc, char **argv)
                           get_existing_partition() only works for Linux-like
                           partition tables */
                                if (!LABEL_IS_SGI) {
                           get_existing_partition() only works for Linux-like
                           partition tables */
                                if (!LABEL_IS_SGI) {

-                                       j = get_existing_partition(1, partitions);
+                                       j = get_existing_partition(1, g_partitions);

                                } else {
                                } else {

-                                       j = get_partition(1, partitions);
+                                       j = get_partition(1, g_partitions);

                                }
                                if (j >= 0)
                                        delete_partition(j);
                                }
                                if (j >= 0)
                                        delete_partition(j);


@@ -3021,11 +3081,12 @@ int fdisk_main(int argc, char **argv)
                        list_table(0);
                        break;
                case 'q':
                        list_table(0);
                        break;
                case 'q':

-                       close(fd);
-                       puts("");
+                       if (ENABLE_FEATURE_CLEAN_UP)
+                               close_dev_fd();
+                       bb_putchar('\n');

                        return 0;
                case 's':
                        return 0;
                case 's':

-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL

                        create_sunlabel();
 #endif
                        break;
                        create_sunlabel();
 #endif
                        break;


@@ -3039,13 +3100,13 @@ int fdisk_main(int argc, char **argv)
                        verify();
                        break;
                case 'w':
                        verify();
                        break;
                case 'w':

-                       write_table();          /* does not return */
+                       write_table();  /* does not return */

                        break;
                        break;

-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED

                case 'x':
                        if (LABEL_IS_SGI) {
                case 'x':
                        if (LABEL_IS_SGI) {

-                               printf(_("\n\tSorry, no experts menu for SGI "
-                                       "partition tables available.\n\n"));
+                               puts("\n\tSorry, no experts menu for SGI "
+                                       "partition tables available\n");

                        } else
                                xselect();
                        break;
                        } else
                                xselect();
                        break;


@@ -3056,5 +3117,5 @@ int fdisk_main(int argc, char **argv)
                }
        }
        return 0;
                }
        }
        return 0;

-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */

 }
 }