Changeset 1765 in MondoRescue for branches/2.2.5/mindi-busybox/util-linux

Timestamp:

Nov 4, 2007, 3:16:40 AM (16 years ago)

Author:

Bruno Cornec

Message:

Update to busybox 1.7.2

Location:

branches/2.2.5/mindi-busybox/util-linux

Files:

• Config.in (modified) (34 diffs)
• Kbuild (added)
• Makefile (deleted)
• Makefile.in (deleted)
• dmesg.c (modified) (2 diffs)
• fbset.c (modified) (10 diffs)
• fdformat.c (modified) (5 diffs)
• fdisk.c (modified) (122 diffs)
• fdisk_aix.c (added)
• fdisk_osf.c (added)
• fdisk_sgi.c (added)
• fdisk_sun.c (added)
• freeramdisk.c (modified) (1 diff)
• fsck_minix.c (modified) (55 diffs)
• getopt.c (modified) (10 diffs)
• hexdump.c (modified) (5 diffs)
• hwclock.c (modified) (6 diffs)
• ipcrm.c (modified) (9 diffs)
• ipcs.c (modified) (21 diffs)
• losetup.c (modified) (2 diffs)
• mdev.c (modified) (9 diffs)
• minix.h (added)
• mkfs_minix.c (modified) (16 diffs)
• mkswap.c (modified) (1 diff)
• more.c (modified) (3 diffs)
• mount.c (modified) (21 diffs)
• nfsmount.c (deleted)
• nfsmount.h (deleted)
• pivot_root.c (modified) (1 diff)
• rdate.c (modified) (6 diffs)
• readprofile.c (modified) (14 diffs)
• setarch.c (modified) (2 diffs)
• swaponoff.c (modified) (4 diffs)
• switch_root.c (modified) (8 diffs)
• umount.c (modified) (10 diffs)

branches/2.2.5/mindi-busybox/util-linux/Config.in

@@ -6 +6 @@
 menu "Linux System Utilities"
 
-config CONFIG_DMESG
+config DMESG
     bool "dmesg"
     default n
@@ -18 +18 @@
       wish to enable the 'dmesg' utility.
 
-config CONFIG_FBSET
+config FEATURE_DMESG_PRETTY
+    bool "pretty dmesg output"
+    default y
+    depends on DMESG
+    help
+      If you wish to scrub the syslog level from the output, say 'Y' here.
+      The syslog level is a string prefixed to every line with the form "<#>".
+
+      With this option you will see:
+        # dmesg
+        Linux version 2.6.17.4 .....
+        BIOS-provided physical RAM map:
+         BIOS-e820: 0000000000000000 - 000000000009f000 (usable)
+
+      Without this option you will see:
+        # dmesg
+        <5>Linux version 2.6.17.4 .....
+        <6>BIOS-provided physical RAM map:
+        <6> BIOS-e820: 0000000000000000 - 000000000009f000 (usable)
+
+config FBSET
     bool "fbset"
     default n
@@ -27 +47 @@
       if you wish to enable the 'fbset' utility.
 
-config CONFIG_FEATURE_FBSET_FANCY
+config FEATURE_FBSET_FANCY
     bool "Turn on extra fbset options"
     default n
-    depends on CONFIG_FBSET
+    depends on FBSET
     help
       This option enables extended fbset options, allowing one to set the
@@ -37 +57 @@
       options.
 
-config CONFIG_FEATURE_FBSET_READMODE
+config FEATURE_FBSET_READMODE
     bool "Turn on fbset readmode support"
     default n
-    depends on CONFIG_FBSET
+    depends on FBSET
     help
       This option allows fbset to read the video mode database stored by
@@ -46 +66 @@
       device to pre-defined video modes.
 
-config CONFIG_FDFLUSH
+config FDFLUSH
     bool "fdflush"
     default n
@@ -58 +78 @@
       leave this disabled.
 
-config CONFIG_FDFORMAT
+config FDFORMAT
     bool "fdformat"
     default n
@@ -64 +84 @@
       fdformat is used to low-level format a floppy disk.
 
-config CONFIG_FDISK
+config FDISK
     bool "fdisk"
     default n
@@ -76 +96 @@
     bool "support over 4GB disks"
     default y
-    depends on CONFIG_FDISK
+    depends on FDISK
     help
       Enable this option to support large disks > 4GB.
 
-config CONFIG_FEATURE_FDISK_WRITABLE
+config FEATURE_FDISK_WRITABLE
     bool "Write support"
     default y
-    depends on CONFIG_FDISK
+    depends on FDISK
     help
       Enabling this option allows you to create or change a partition table
@@ -89 +109 @@
       disabled, you will only be able to view the partition table.
 
-config CONFIG_FEATURE_AIX_LABEL
+config FEATURE_AIX_LABEL
     bool "Support AIX disklabels"
     default n
-    depends on CONFIG_FDISK && CONFIG_FEATURE_FDISK_WRITABLE
+    depends on FDISK && FEATURE_FDISK_WRITABLE
     help
       Enabling this option allows you to create or change AIX disklabels.
       Most people can safely leave this option disabled.
 
-config CONFIG_FEATURE_SGI_LABEL
+config FEATURE_SGI_LABEL
     bool "Support SGI disklabels"
     default n
-    depends on CONFIG_FDISK && CONFIG_FEATURE_FDISK_WRITABLE
+    depends on FDISK && FEATURE_FDISK_WRITABLE
     help
       Enabling this option allows you to create or change SGI disklabels.
       Most people can safely leave this option disabled.
 
-config CONFIG_FEATURE_SUN_LABEL
+config FEATURE_SUN_LABEL
     bool "Support SUN disklabels"
     default n
-    depends on CONFIG_FDISK && CONFIG_FEATURE_FDISK_WRITABLE
+    depends on FDISK && FEATURE_FDISK_WRITABLE
     help
       Enabling this option allows you to create or change SUN disklabels.
       Most people can safely leave this option disabled.
 
-config CONFIG_FEATURE_OSF_LABEL
+config FEATURE_OSF_LABEL
     bool "Support BSD disklabels"
     default n
-    depends on CONFIG_FDISK && CONFIG_FEATURE_FDISK_WRITABLE
+    depends on FDISK && FEATURE_FDISK_WRITABLE
     help
       Enabling this option allows you to create or change BSD disklabels
       and define and edit BSD disk slices.
 
-config CONFIG_FEATURE_FDISK_ADVANCED
+config FEATURE_FDISK_ADVANCED
     bool "Support expert mode"
     default n
-    depends on CONFIG_FDISK && CONFIG_FEATURE_FDISK_WRITABLE
+    depends on FDISK && FEATURE_FDISK_WRITABLE
     help
       Enabling this option allows you to do terribly unsafe things like
@@ -131 +151 @@
       reason you would be wise to leave this disabled.
 
-config CONFIG_FREERAMDISK
+config FREERAMDISK
     bool "freeramdisk"
     default n
@@ -142 +162 @@
       this disabled.
 
-config CONFIG_FSCK_MINIX
+config FSCK_MINIX
     bool "fsck_minix"
     default n
@@ -153 +173 @@
       filesystem.
 
-config CONFIG_MKFS_MINIX
+config MKFS_MINIX
     bool "mkfs_minix"
     default n
@@ -162 +182 @@
 
 comment "Minix filesystem support"
-    depends on CONFIG_FSCK_MINIX || CONFIG_MKFS_MINIX
-
-config CONFIG_FEATURE_MINIX2
+    depends on FSCK_MINIX || MKFS_MINIX
+
+config FEATURE_MINIX2
     bool "Support Minix fs v2 (fsck_minix/mkfs_minix)"
     default y
-    depends on CONFIG_FSCK_MINIX || CONFIG_MKFS_MINIX
+    depends on FSCK_MINIX || MKFS_MINIX
     help
       If you wish to be able to create version 2 minix filesystems, enable this.
@@ -173 +193 @@
       version 2 filesystem support.
 
-config CONFIG_GETOPT
+config GETOPT
     bool "getopt"
     default n
@@ -184 +204 @@
       wisely leave this disabled.
 
-config CONFIG_HEXDUMP
+config HEXDUMP
     bool "hexdump"
     default n
@@ -191 +211 @@
       way that is comparable to the output from most hex editors.
 
-config CONFIG_HWCLOCK
+config HWCLOCK
     bool "hwclock"
     default n
@@ -200 +220 @@
       correct time when Linux is _not_ running.
 
-config CONFIG_FEATURE_HWCLOCK_LONG_OPTIONS
+config FEATURE_HWCLOCK_LONG_OPTIONS
     bool "Support long options (--hctosys,...)"
     default n
-    depends on CONFIG_HWCLOCK && CONFIG_GETOPT_LONG
+    depends on HWCLOCK && GETOPT_LONG
     help
       By default, the hwclock utility only uses short options.  If you
@@ -209 +229 @@
       then enable this option.
 
-config CONFIG_FEATURE_HWCLOCK_ADJTIME_FHS
+config FEATURE_HWCLOCK_ADJTIME_FHS
     bool "Use FHS /var/lib/hwclock/adjtime"
     default y
-    depends on CONFIG_HWCLOCK
+    depends on HWCLOCK
     help
       Starting with FHS 2.3, the adjtime state file is supposed to exist
@@ -221 +241 @@
       http://www.pathname.com/fhs/pub/fhs-2.3.html#VARLIBHWCLOCKSTATEDIRECTORYFORHWCLO
 
-config CONFIG_IPCRM
+config IPCRM
     bool "ipcrm"
     default n
-    select CONFIG_FEATURE_SUID
+    select FEATURE_SUID
     help
       The ipcrm utility allows the removal of System V interprocess
@@ -230 +250 @@
       from the system.
 
-config CONFIG_IPCS
+config IPCS
     bool "ipcs"
     default n
-    select CONFIG_FEATURE_SUID
+    select FEATURE_SUID
     help
       The ipcs utility is used to provide information on the currently
       allocated System V interprocess (IPC) objects in the system.
 
-config CONFIG_LOSETUP
+config LOSETUP
     bool "losetup"
     default n
@@ -246 +266 @@
       version does not currently support enabling data encryption.
 
-config CONFIG_MDEV
+config MDEV
     bool "mdev"
     default n
     help
-      mdev is a mini-udev implementation: call it with -s to populate
-      /dev from /sys, then "echo /sbin/mdev > /proc/sys/kernel/hotplug" to
-      have it handle hotplug events afterwards.  Device names are taken
-      from sysfs.
-
-config CONFIG_FEATURE_MDEV_CONF
+      mdev is a mini-udev implementation for dynamically creating device
+      nodes in the /dev directory.
+
+      For more information, please see docs/mdev.txt
+
+config FEATURE_MDEV_CONF
     bool "Support /etc/mdev.conf"
     default n
-    depends on CONFIG_MDEV
-    help
-      The mdev config file contains lines that look like:
-
-        hd[a-z][0-9]* 0:3 660
-
-      That's device name (with regex match), uid:gid, and permissions.
-
-      Config file parsing stops on the first matching line.  If no config
-      entry is matched, devices are created with default 0:0 660.  (Make
-      the last line match .* to override this.)
-
-config CONFIG_FEATURE_MDEV_EXEC
+    depends on MDEV
+    help
+      Add support for the mdev config file to control ownership and
+      permissions of the device nodes.
+
+      For more information, please see docs/mdev.txt
+
+config FEATURE_MDEV_EXEC
     bool "Support command execution at device addition/removal"
     default n
-    depends on CONFIG_FEATURE_MDEV_CONF
-    help
-      This adds support for an optional field to /etc/mdev.conf, consisting
-      of a special character and a command line to run after creating the
-      corresponding device(s) and before removing, ala:
-
-        hdc root:cdrom 660  *ln -s $MDEV cdrom
-
-      The $MDEV environment variable is set to the name of the device.
-
-      The special characters and their meanings are:
-        @ Run after creating the device.
-        $ Run before removing the device.
-        * Run both after creating and before removing the device.
-
-      Commands are executed via system() so you need /bin/sh, meaning you
-      probably want to select a default shell in the Shells menu.
-
-config CONFIG_MKSWAP
+    depends on FEATURE_MDEV_CONF
+    help
+      This adds support for an optional field to /etc/mdev.conf for
+      executing commands when devices are created/removed.
+
+      For more information, please see docs/mdev.txt
+
+config FEATURE_MDEV_LOAD_FIRMWARE
+    bool "Support loading of firmwares"
+    default n
+    depends on MDEV
+    help
+      Some devices need to load firmware before they can be usable.
+
+      These devices will request userspace look up the files in
+      /lib/firmware/ and if it exists, send it to the kernel for
+      loading into the hardware.
+
+config MKSWAP
     bool "mkswap"
     default n
@@ -304 +319 @@
       the swap space using the 'swapon' utility.
 
-config CONFIG_FEATURE_MKSWAP_V0
+config FEATURE_MKSWAP_V0
     bool "version 0 support"
     default n
-    depends on CONFIG_MKSWAP
-#   depends on CONFIG_MKSWAP && CONFIG_DEPRECATED
+    depends on MKSWAP
+#   depends on MKSWAP && DEPRECATED
     help
       Enable support for the old v0 style.
@@ -314 +329 @@
       only option.
 
-config CONFIG_MORE
+config MORE
     bool "more"
     default n
@@ -324 +339 @@
       any need to reading text files, you can leave this disabled.
 
-config CONFIG_FEATURE_USE_TERMIOS
+config FEATURE_USE_TERMIOS
     bool "Use termios to manipulate the screen"
     default y
-    depends on CONFIG_MORE
+    depends on MORE
     help
       This option allows utilities such as 'more' and 'top' to determine
@@ -335 +350 @@
       unable to move the cursor.
 
-config CONFIG_MOUNT
+config MOUNT
     bool "mount"
     default n
@@ -346 +361 @@
       the 'mount' utility.
 
-config CONFIG_FEATURE_MOUNT_NFS
+config FEATURE_MOUNT_NFS
     bool "Support mounting NFS file systems"
     default n
-    depends on CONFIG_MOUNT
-    help
-     Enable mounting of NFS file systems.
-
-config CONFIG_PIVOT_ROOT
+    depends on MOUNT
+    select FEATURE_HAVE_RPC
+    select FEATURE_SYSLOG
+    help
+      Enable mounting of NFS file systems.
+
+config FEATURE_MOUNT_CIFS
+    bool "Support mounting CIFS/SMB file systems"
+    default n
+    depends on MOUNT
+    help
+      Enable support for samba mounts.
+
+config FEATURE_MOUNT_FLAGS
+    depends on MOUNT
+    bool "Support lots of -o flags in mount"
+    default y
+    help
+      Without this, mount only supports ro/rw/remount.  With this, it
+      supports nosuid, suid, dev, nodev, exec, noexec, sync, async, atime,
+      noatime, diratime, nodiratime, loud, bind, move, shared, slave,
+      private, unbindable, rshared, rslave, rprivate, and runbindable.
+
+config FEATURE_MOUNT_FSTAB
+    depends on MOUNT
+    bool "Support /etc/fstab and -a"
+    default y
+    help
+      Support mount all and looking for files in /etc/fstab.
+
+config PIVOT_ROOT
     bool "pivot_root"
     default n
@@ -365 +406 @@
       in linux 2.6) use switch_root instead.
 
-config CONFIG_RDATE
+config RDATE
     bool "rdate"
     default n
@@ -374 +415 @@
       systems.
 
-config CONFIG_READPROFILE
+config READPROFILE
     bool "readprofile"
     default n
@@ -380 +421 @@
       This allows you to parse /proc/profile for basic profiling.
 
-config CONFIG_SETARCH
+config SETARCH
     bool "setarch"
     default n
@@ -389 +430 @@
       (like amd64/x86, ppc64/ppc, sparc64/sparc, etc...).
 
-config CONFIG_SWAPONOFF
+config SWAPONOFF
     bool "swaponoff"
     default n
@@ -400 +441 @@
       option disabled.
 
-config CONFIG_SWITCH_ROOT
+config SWITCH_ROOT
     bool "switch_root"
     default n
@@ -419 +460 @@
       list of active mount points.  That's why.
 
-config CONFIG_UMOUNT
+config UMOUNT
     bool "umount"
     default n
@@ -428 +469 @@
       also want to enable 'umount'.
 
-config CONFIG_FEATURE_UMOUNT_ALL
+config FEATURE_UMOUNT_ALL
     bool "umount -a option"
     default n
-    depends on CONFIG_UMOUNT
+    depends on UMOUNT
     help
       Support -a option to unmount all currently mounted filesystems.
 
 comment "Common options for mount/umount"
-    depends on CONFIG_MOUNT || CONFIG_UMOUNT
-
-config CONFIG_FEATURE_MOUNT_LOOP
+    depends on MOUNT || UMOUNT
+
+config FEATURE_MOUNT_LOOP
     bool "Support loopback mounts"
     default n
-    depends on CONFIG_MOUNT || CONFIG_UMOUNT
+    depends on MOUNT || UMOUNT
     help
       Enabling this feature allows automatic mounting of files (containing
@@ -450 +491 @@
 
       You can still use the 'losetup' utility (to manually associate files
-          with loop devices) if you need to do something advanced, such as
+      with loop devices) if you need to do something advanced, such as
       specify an offset or cryptographic options to the loopback device.
       (If you don't want umount to free the loop device, use "umount -D".)
 
-config CONFIG_FEATURE_MTAB_SUPPORT
+config FEATURE_MTAB_SUPPORT
     bool "Support for the old /etc/mtab file"
     default n
-    depends on CONFIG_MOUNT || CONFIG_UMOUNT
+    depends on MOUNT || UMOUNT
     help
       Historically, Unix systems kept track of the currently mounted

branches/2.2.5/mindi-busybox/util-linux/dmesg.c

@@ -1 @@
-/* vi: set ts=4:
- * 
+/* vi: set sw=4 ts=4: */
+/*
+ *
  * dmesg - display/control kernel ring buffer.
  *
- * Copyring 2006 Rob Landley <rob@landley.net>
+ * Copyright 2006 Rob Landley <rob@landley.net>
+ * Copyright 2006 Bernhard Fischer <rep.nop@aon.at>
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2, see file LICENSE in this tarball for details.
  */
 
-#include "busybox.h"
-#include <unistd.h>
 #include <sys/klog.h>
+#include "libbb.h"
 
-int dmesg_main(int argc, char *argv[])
+int dmesg_main(int argc, char **argv);
+int dmesg_main(int argc, char **argv)
 {
     char *size, *level;
-    int flags = bb_getopt_ulflags(argc, argv, "cs:n:", &size, &level);
+    int flags = getopt32(argv, "cs:n:", &size, &level);
 
     if (flags & 4) {
-        if(klogctl(8, NULL, bb_xgetlarg(level, 10, 0, 10)))
+        if (klogctl(8, NULL, xatoul_range(level, 0, 10)))
             bb_perror_msg_and_die("klogctl");
     } else {
@@ -24 +26 @@
         char *buf;
 
-        len = (flags & 2) ? bb_xgetlarg(size, 10, 2, INT_MAX) : 16384;
+        len = (flags & 2) ? xatoul_range(size, 2, INT_MAX) : 16384;
         buf = xmalloc(len);
         if (0 > (len = klogctl(3 + (flags & 1), buf, len)))
             bb_perror_msg_and_die("klogctl");
-        write(1,buf,len);
-        if (len && buf[len-1]!='\n') putchar('\n');
+
+        // Skip <#> at the start of lines, and make sure we end with a newline.
+
+        if (ENABLE_FEATURE_DMESG_PRETTY) {
+            int last = '\n';
+            int in;
+
+            for (in = 0; in<len;) {
+                if (last == '\n' && buf[in] == '<') in += 3;
+                else putchar(last = buf[in++]);
+            }
+            if (last != '\n') putchar('\n');
+        } else {
+            write(1,buf,len);
+            if (len && buf[len-1]!='\n') putchar('\n');
+        }
+
+        if (ENABLE_FEATURE_CLEAN_UP) free(buf);
     }
 

branches/2.2.5/mindi-busybox/util-linux/fbset.c

@@ -13 +13 @@
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <ctype.h>
-#include <string.h>
-#include <stdint.h>
-#include <sys/ioctl.h>
-#include "busybox.h"
+#include "libbb.h"
 
 #define DEFAULTFBDEV  FB_0
@@ -31 +22 @@
     OPT_INFO     = (1 << 1),
     OPT_READMODE = (1 << 2),
+    OPT_ALL      = (1 << 9),
 
     CMD_FB = 1,
@@ -46 +38 @@
     CMD_CHANGE = 13,
 
-#ifdef CONFIG_FEATURE_FBSET_FANCY
+#if ENABLE_FEATURE_FBSET_FANCY
     CMD_XRES = 100,
     CMD_YRES = 101,
@@ -70 +62 @@
 };
 
-static unsigned int g_options = 0;
+static unsigned g_options;
 
 /* Stuff stolen from the kernel's fb.h */
+#define FB_ACTIVATE_ALL 64
 enum {
     FBIOGET_VSCREENINFO = 0x4600,
@@ -78 +71 @@
 };
 struct fb_bitfield {
-    uint32_t offset;            /* beginning of bitfield    */
-    uint32_t length;            /* length of bitfield       */
-    uint32_t msb_right;     /* != 0 : Most significant bit is */
-                    /* right */
+    uint32_t offset;                /* beginning of bitfield */
+    uint32_t length;        /* length of bitfield */
+    uint32_t msb_right;             /* !=0: Most significant bit is right */
 };
 struct fb_var_screeninfo {
-    uint32_t xres;          /* visible resolution       */
+    uint32_t xres;                  /* visible resolution */
     uint32_t yres;
-    uint32_t xres_virtual;      /* virtual resolution       */
+    uint32_t xres_virtual;          /* virtual resolution */
     uint32_t yres_virtual;
-    uint32_t xoffset;           /* offset from virtual to visible */
-    uint32_t yoffset;           /* resolution           */
-
-    uint32_t bits_per_pixel;        /* guess what           */
-    uint32_t grayscale;     /* != 0 Graylevels instead of colors */
-
-    struct fb_bitfield red;     /* bitfield in fb mem if true color, */
-    struct fb_bitfield green;   /* else only length is significant */
+    uint32_t xoffset;               /* offset from virtual to visible */
+    uint32_t yoffset;               /* resolution */
+
+    uint32_t bits_per_pixel;
+    uint32_t grayscale;             /* !=0 Graylevels instead of colors */
+
+    struct fb_bitfield red;         /* bitfield in fb mem if true color, */
+    struct fb_bitfield green;       /* else only length is significant */
     struct fb_bitfield blue;
-    struct fb_bitfield transp;  /* transparency         */
-
-    uint32_t nonstd;            /* != 0 Non standard pixel format */
-
-    uint32_t activate;          /* see FB_ACTIVATE_*        */
-
-    uint32_t height;            /* height of picture in mm    */
-    uint32_t width;         /* width of picture in mm     */
+    struct fb_bitfield transp;      /* transparency */
+
+    uint32_t nonstd;                /* !=0 Non standard pixel format */
+
+    uint32_t activate;              /* see FB_ACTIVATE_x */
+
+    uint32_t height;                /* height of picture in mm */
+    uint32_t width;                 /* width of picture in mm */
 
     uint32_t accel_flags;       /* acceleration flags (hints)   */
 
     /* Timing: All values in pixclocks, except pixclock (of course) */
-    uint32_t pixclock;          /* pixel clock in ps (pico seconds) */
-    uint32_t left_margin;       /* time from sync to picture    */
-    uint32_t right_margin;      /* time from picture to sync    */
-    uint32_t upper_margin;      /* time from sync to picture    */
+    uint32_t pixclock;              /* pixel clock in ps (pico seconds) */
+    uint32_t left_margin;           /* time from sync to picture */
+    uint32_t right_margin;          /* time from picture to sync */
+    uint32_t upper_margin;          /* time from sync to picture */
     uint32_t lower_margin;
-    uint32_t hsync_len;     /* length of horizontal sync    */
-    uint32_t vsync_len;     /* length of vertical sync  */
-    uint32_t sync;          /* see FB_SYNC_*        */
-    uint32_t vmode;         /* see FB_VMODE_*       */
-    uint32_t reserved[6];       /* Reserved for future compatibility */
+    uint32_t hsync_len;             /* length of horizontal sync */
+    uint32_t vsync_len;             /* length of vertical sync */
+    uint32_t sync;                  /* see FB_SYNC_x */
+    uint32_t vmode;                 /* see FB_VMODE_x */
+    uint32_t reserved[6];           /* Reserved for future compatibility */
 };
 
 
 static const struct cmdoptions_t {
-    const char *name;
+    const char name[10];
     const unsigned char param_count;
     const unsigned char code;
 } g_cmdoptions[] = {
-    {
-    "-fb", 1, CMD_FB}, {
-    "-db", 1, CMD_DB}, {
-    "-a", 0, CMD_ALL}, {
-    "-i", 0, CMD_INFO}, {
-    "-g", 5, CMD_GEOMETRY}, {
-    "-t", 7, CMD_TIMING}, {
-    "-accel", 1, CMD_ACCEL}, {
-    "-hsync", 1, CMD_HSYNC}, {
-    "-vsync", 1, CMD_VSYNC}, {
-    "-laced", 1, CMD_LACED}, {
-    "-double", 1, CMD_DOUBLE}, {
-    "-n", 0, CMD_CHANGE}, {
-#ifdef CONFIG_FEATURE_FBSET_FANCY
-    "-all", 0, CMD_ALL}, {
-    "-xres", 1, CMD_XRES}, {
-    "-yres", 1, CMD_YRES}, {
-    "-vxres", 1, CMD_VXRES}, {
-    "-vyres", 1, CMD_VYRES}, {
-    "-depth", 1, CMD_DEPTH}, {
-    "-match", 0, CMD_MATCH}, {
-    "-geometry", 5, CMD_GEOMETRY}, {
-    "-pixclock", 1, CMD_PIXCLOCK}, {
-    "-left", 1, CMD_LEFT}, {
-    "-right", 1, CMD_RIGHT}, {
-    "-upper", 1, CMD_UPPER}, {
-    "-lower", 1, CMD_LOWER}, {
-    "-hslen", 1, CMD_HSLEN}, {
-    "-vslen", 1, CMD_VSLEN}, {
-    "-timings", 7, CMD_TIMING}, {
-    "-csync", 1, CMD_CSYNC}, {
-    "-gsync", 1, CMD_GSYNC}, {
-    "-extsync", 1, CMD_EXTSYNC}, {
-    "-bcast", 1, CMD_BCAST}, {
-    "-rgba", 1, CMD_RGBA}, {
-    "-step", 1, CMD_STEP}, {
-    "-move", 1, CMD_MOVE}, {
-#endif
-    0, 0, 0}
-};
-
-#ifdef CONFIG_FEATURE_FBSET_READMODE
+    { "-fb", 1, CMD_FB },
+    { "-db", 1, CMD_DB },
+    { "-a", 0, CMD_ALL },
+    { "-i", 0, CMD_INFO },
+    { "-g", 5, CMD_GEOMETRY },
+    { "-t", 7, CMD_TIMING },
+    { "-accel", 1, CMD_ACCEL },
+    { "-hsync", 1, CMD_HSYNC },
+    { "-vsync", 1, CMD_VSYNC },
+    { "-laced", 1, CMD_LACED },
+    { "-double", 1, CMD_DOUBLE },
+    { "-n", 0, CMD_CHANGE },
+#if ENABLE_FEATURE_FBSET_FANCY
+    { "-all", 0, CMD_ALL },
+    { "-xres", 1, CMD_XRES },
+    { "-yres", 1, CMD_YRES },
+    { "-vxres", 1, CMD_VXRES },
+    { "-vyres", 1, CMD_VYRES },
+    { "-depth", 1, CMD_DEPTH },
+    { "-match", 0, CMD_MATCH },
+    { "-geometry", 5, CMD_GEOMETRY },
+    { "-pixclock", 1, CMD_PIXCLOCK },
+    { "-left", 1, CMD_LEFT },
+    { "-right", 1, CMD_RIGHT },
+    { "-upper", 1, CMD_UPPER },
+    { "-lower", 1, CMD_LOWER },
+    { "-hslen", 1, CMD_HSLEN },
+    { "-vslen", 1, CMD_VSLEN },
+    { "-timings", 7, CMD_TIMING },
+    { "-csync", 1, CMD_CSYNC },
+    { "-gsync", 1, CMD_GSYNC },
+    { "-extsync", 1, CMD_EXTSYNC },
+    { "-bcast", 1, CMD_BCAST },
+    { "-rgba", 1, CMD_RGBA },
+    { "-step", 1, CMD_STEP },
+    { "-move", 1, CMD_MOVE },
+#endif
+    { "", 0, 0 }
+};
+
+#if ENABLE_FEATURE_FBSET_READMODE
 /* taken from linux/fb.h */
 enum {
@@ -179 +170 @@
 };
 #endif
+
 static int readmode(struct fb_var_screeninfo *base, const char *fn,
                     const char *mode)
 {
-#ifdef CONFIG_FEATURE_FBSET_READMODE
+#if ENABLE_FEATURE_FBSET_READMODE
     FILE *f;
     char buf[256];
     char *p = buf;
 
-    f = bb_xfopen(fn, "r");
+    f = xfopen(fn, "r");
     while (!feof(f)) {
         fgets(buf, sizeof(buf), f);
-        if ((p = strstr(buf, "mode ")) || (p = strstr(buf, "mode\t"))) {
-            p += 5;
-            if ((p = strstr(buf, mode))) {
-                p += strlen(mode);
-                if (!isspace(*p) && (*p != 0) && (*p != '"')
-                    && (*p != '\r') && (*p != '\n'))
-                    continue;   /* almost, but not quite */
-                while (!feof(f)) {
-                    fgets(buf, sizeof(buf), f);
-
-            if ((p = strstr(buf, "geometry "))) {
-            p += 9;
-
-            sscanf(p, "%d %d %d %d %d",
-                &(base->xres), &(base->yres),
-                &(base->xres_virtual), &(base->yres_virtual),
-                &(base->bits_per_pixel));
-            } else if ((p = strstr(buf, "timings "))) {
-            p += 8;
-
-            sscanf(p, "%d %d %d %d %d %d %d",
-                &(base->pixclock),
-                &(base->left_margin), &(base->right_margin),
-                &(base->upper_margin), &(base->lower_margin),
-                &(base->hsync_len), &(base->vsync_len));
-            } else if ((p = strstr(buf, "laced "))) {
-            p += 6;
-
-            if (strstr(buf, "false")) {
-                base->vmode &= ~FB_VMODE_INTERLACED;
-            } else {
-                base->vmode |= FB_VMODE_INTERLACED;
+        if (!(p = strstr(buf, "mode ")) && !(p = strstr(buf, "mode\t")))
+            continue;
+        p += 5;
+        if (!(p = strstr(buf, mode)))
+            continue;
+        p += strlen(mode);
+        if (!isspace(*p) && (*p != 0) && (*p != '"')
+                && (*p != '\r') && (*p != '\n'))
+            continue;   /* almost, but not quite */
+
+        while (!feof(f)) {
+            fgets(buf, sizeof(buf), f);
+            if ((p = strstr(buf, "geometry "))) {
+                p += 9;
+                /* FIXME: catastrophic on arches with 64bit ints */
+                sscanf(p, "%d %d %d %d %d",
+                    &(base->xres), &(base->yres),
+                    &(base->xres_virtual), &(base->yres_virtual),
+                    &(base->bits_per_pixel));
+            } else if ((p = strstr(buf, "timings "))) {
+                p += 8;
+                sscanf(p, "%d %d %d %d %d %d %d",
+                    &(base->pixclock),
+                    &(base->left_margin), &(base->right_margin),
+                    &(base->upper_margin), &(base->lower_margin),
+                    &(base->hsync_len), &(base->vsync_len));
+            } else if ((p = strstr(buf, "laced "))) {
+                //p += 6;
+                if (strstr(buf, "false")) {
+                    base->vmode &= ~FB_VMODE_INTERLACED;
+                } else {
+                    base->vmode |= FB_VMODE_INTERLACED;
+                }
+            } else if ((p = strstr(buf, "double "))) {
+                //p += 7;
+                if (strstr(buf, "false")) {
+                    base->vmode &= ~FB_VMODE_DOUBLE;
+                } else {
+                    base->vmode |= FB_VMODE_DOUBLE;
+                }
+            } else if ((p = strstr(buf, "vsync "))) {
+                //p += 6;
+                if (strstr(buf, "low")) {
+                    base->sync &= ~FB_SYNC_VERT_HIGH_ACT;
+                } else {
+                    base->sync |= FB_SYNC_VERT_HIGH_ACT;
+                }
+            } else if ((p = strstr(buf, "hsync "))) {
+                //p += 6;
+                if (strstr(buf, "low")) {
+                    base->sync &= ~FB_SYNC_HOR_HIGH_ACT;
+                } else {
+                    base->sync |= FB_SYNC_HOR_HIGH_ACT;
+                }
+            } else if ((p = strstr(buf, "csync "))) {
+                //p += 6;
+                if (strstr(buf, "low")) {
+                    base->sync &= ~FB_SYNC_COMP_HIGH_ACT;
+                } else {
+                    base->sync |= FB_SYNC_COMP_HIGH_ACT;
+                }
+            } else if ((p = strstr(buf, "extsync "))) {
+                //p += 8;
+                if (strstr(buf, "false")) {
+                    base->sync &= ~FB_SYNC_EXT;
+                } else {
+                    base->sync |= FB_SYNC_EXT;
+                }
             }
-            } else if ((p = strstr(buf, "double "))) {
-            p += 7;
-
-            if (strstr(buf, "false")) {
-                base->vmode &= ~FB_VMODE_DOUBLE;
-            } else {
-                base->vmode |= FB_VMODE_DOUBLE;
-            }
-            } else if ((p = strstr(buf, "vsync "))) {
-            p += 6;
-
-            if (strstr(buf, "low")) {
-                base->sync &= ~FB_SYNC_VERT_HIGH_ACT;
-            } else {
-                base->sync |= FB_SYNC_VERT_HIGH_ACT;
-            }
-            } else if ((p = strstr(buf, "hsync "))) {
-            p += 6;
-
-            if (strstr(buf, "low")) {
-                base->sync &= ~FB_SYNC_HOR_HIGH_ACT;
-            } else {
-                base->sync |= FB_SYNC_HOR_HIGH_ACT;
-            }
-            } else if ((p = strstr(buf, "csync "))) {
-            p += 6;
-
-            if (strstr(buf, "low")) {
-                base->sync &= ~FB_SYNC_COMP_HIGH_ACT;
-            } else {
-                base->sync |= FB_SYNC_COMP_HIGH_ACT;
-            }
-            } else if ((p = strstr(buf, "extsync "))) {
-            p += 8;
-
-            if (strstr(buf, "false")) {
-                base->sync &= ~FB_SYNC_EXT;
-            } else {
-                base->sync |= FB_SYNC_EXT;
-            }
-            }
-
-                    if (strstr(buf, "endmode"))
-                        return 1;
-                }
-            }
+
+            if (strstr(buf, "endmode"))
+                return 1;
         }
     }
 #else
-    bb_error_msg( "mode reading not compiled in");
+    bb_error_msg("mode reading not compiled in");
 #endif
     return 0;
@@ -298 +283 @@
     if (v->pixclock) {
         drate = 1e12 / v->pixclock;
-        hrate =
-            drate / (v->left_margin + v->xres + v->right_margin +
-                     v->hsync_len);
-        vrate =
-            hrate / (v->upper_margin + v->yres + v->lower_margin +
-                     v->vsync_len);
+        hrate = drate / (v->left_margin + v->xres + v->right_margin + v->hsync_len);
+        vrate = hrate / (v->upper_margin + v->yres + v->lower_margin + v->vsync_len);
     }
     printf("\nmode \"%ux%u-%u\"\n"
-#ifdef CONFIG_FEATURE_FBSET_FANCY
+#if ENABLE_FEATURE_FBSET_FANCY
     "\t# D: %.3f MHz, H: %.3f kHz, V: %.3f Hz\n"
 #endif
-    "\tgeometry %u %u %u %u %u\n\ttimings %u %u %u %u %u %u %u\n\taccel %s\n\trgba %u/%u,%u/%u,%u/%u,%u/%u\nendmode\n\n",
-           v->xres, v->yres, (int) (vrate + 0.5),
-#ifdef CONFIG_FEATURE_FBSET_FANCY
-           drate / 1e6, hrate / 1e3, vrate,
-#endif
-           v->xres, v->yres, v->xres_virtual, v->yres_virtual,
-           v->bits_per_pixel, v->pixclock, v->left_margin,
-           v->right_margin, v->upper_margin, v->lower_margin, v->hsync_len,
-           v->vsync_len, (v->accel_flags > 0 ? "true" : "false"), v->red.length,
-           v->red.offset, v->green.length, v->green.offset, v->blue.length,
-           v->blue.offset, v->transp.length, v->transp.offset);
+    "\tgeometry %u %u %u %u %u\n"
+    "\ttimings %u %u %u %u %u %u %u\n"
+    "\taccel %s\n"
+    "\trgba %u/%u,%u/%u,%u/%u,%u/%u\n"
+    "endmode\n\n",
+        v->xres, v->yres, (int) (vrate + 0.5),
+#if ENABLE_FEATURE_FBSET_FANCY
+        drate / 1e6, hrate / 1e3, vrate,
+#endif
+        v->xres, v->yres, v->xres_virtual, v->yres_virtual, v->bits_per_pixel,
+        v->pixclock, v->left_margin, v->right_margin, v->upper_margin, v->lower_margin,
+            v->hsync_len, v->vsync_len,
+        (v->accel_flags > 0 ? "true" : "false"),
+        v->red.length, v->red.offset, v->green.length, v->green.offset,
+            v->blue.length, v->blue.offset, v->transp.length, v->transp.offset);
 }
 
@@ -325 +310 @@
 int main(int argc, char **argv)
 #else
+int fbset_main(int argc, char **argv);
 int fbset_main(int argc, char **argv)
 #endif
@@ -330 +316 @@
     struct fb_var_screeninfo var, varset;
     int fh, i;
-    char *fbdev = DEFAULTFBDEV;
-    char *modefile = DEFAULTFBMODE;
+    const char *fbdev = DEFAULTFBDEV;
+    const char *modefile = DEFAULTFBMODE;
     char *thisarg, *mode = NULL;
 
@@ -340 +326 @@
     argc--;
     for (; argc > 0 && (thisarg = *argv); argc--, argv++) {
-        for (i = 0; g_cmdoptions[i].name; i++) {
-            if (!strcmp(thisarg, g_cmdoptions[i].name)) {
-                if (argc - 1 < g_cmdoptions[i].param_count)
-                    bb_show_usage();
-                switch (g_cmdoptions[i].code) {
-                case CMD_FB:
-                    fbdev = argv[1];
-                    break;
-                case CMD_DB:
-                    modefile = argv[1];
-                    break;
-                case CMD_GEOMETRY:
-                    varset.xres = strtoul(argv[1], 0, 0);
-                    varset.yres = strtoul(argv[2], 0, 0);
-                    varset.xres_virtual = strtoul(argv[3], 0, 0);
-                    varset.yres_virtual = strtoul(argv[4], 0, 0);
-                    varset.bits_per_pixel = strtoul(argv[5], 0, 0);
-                    break;
-                case CMD_TIMING:
-                    varset.pixclock = strtoul(argv[1], 0, 0);
-                    varset.left_margin = strtoul(argv[2], 0, 0);
-                    varset.right_margin = strtoul(argv[3], 0, 0);
-                    varset.upper_margin = strtoul(argv[4], 0, 0);
-                    varset.lower_margin = strtoul(argv[5], 0, 0);
-                    varset.hsync_len = strtoul(argv[6], 0, 0);
-                    varset.vsync_len = strtoul(argv[7], 0, 0);
-                    break;
-        case CMD_CHANGE:
-            g_options |= OPT_CHANGE;
-            break;
-#ifdef CONFIG_FEATURE_FBSET_FANCY
-                case CMD_XRES:
-                    varset.xres = strtoul(argv[1], 0, 0);
-                    break;
-                case CMD_YRES:
-                    varset.yres = strtoul(argv[1], 0, 0);
-                    break;
-               case CMD_DEPTH:
-                    varset.bits_per_pixel = strtoul(argv[1], 0, 0);
-                    break;
-#endif
-                }
-                argc -= g_cmdoptions[i].param_count;
-                argv += g_cmdoptions[i].param_count;
-                break;
+        for (i = 0; g_cmdoptions[i].name[0]; i++) {
+            if (strcmp(thisarg, g_cmdoptions[i].name))
+                continue;
+            if (argc-1 < g_cmdoptions[i].param_count)
+                bb_show_usage();
+
+            switch (g_cmdoptions[i].code) {
+            case CMD_FB:
+                fbdev = argv[1];
+                break;
+            case CMD_DB:
+                modefile = argv[1];
+                break;
+            case CMD_GEOMETRY:
+                varset.xres = xatou32(argv[1]);
+                varset.yres = xatou32(argv[2]);
+                varset.xres_virtual = xatou32(argv[3]);
+                varset.yres_virtual = xatou32(argv[4]);
+                varset.bits_per_pixel = xatou32(argv[5]);
+                break;
+            case CMD_TIMING:
+                varset.pixclock = xatou32(argv[1]);
+                varset.left_margin = xatou32(argv[2]);
+                varset.right_margin = xatou32(argv[3]);
+                varset.upper_margin = xatou32(argv[4]);
+                varset.lower_margin = xatou32(argv[5]);
+                varset.hsync_len = xatou32(argv[6]);
+                varset.vsync_len = xatou32(argv[7]);
+                break;
+            case CMD_ALL:
+                g_options |= OPT_ALL;
+                break;
+            case CMD_CHANGE:
+                g_options |= OPT_CHANGE;
+                break;
+#if ENABLE_FEATURE_FBSET_FANCY
+            case CMD_XRES:
+                varset.xres = xatou32(argv[1]);
+                break;
+            case CMD_YRES:
+                varset.yres = xatou32(argv[1]);
+                break;
+            case CMD_DEPTH:
+                varset.bits_per_pixel = xatou32(argv[1]);
+                break;
+#endif
             }
+            argc -= g_cmdoptions[i].param_count;
+            argv += g_cmdoptions[i].param_count;
+            break;
         }
-        if (!g_cmdoptions[i].name) {
-            if (argc == 1) {
-                mode = *argv;
-                g_options |= OPT_READMODE;
-            } else {
+        if (!g_cmdoptions[i].name[0]) {
+            if (argc != 1)
                 bb_show_usage();
-            }
+            mode = *argv;
+            g_options |= OPT_READMODE;
         }
     }
 
-    fh = bb_xopen(fbdev, O_RDONLY);
-    if (ioctl(fh, FBIOGET_VSCREENINFO, &var))
-        bb_perror_msg_and_die("fbset(ioctl)");
+    fh = xopen(fbdev, O_RDONLY);
+    xioctl(fh, FBIOGET_VSCREENINFO, &var);
     if (g_options & OPT_READMODE) {
         if (!readmode(&var, modefile, mode)) {
-            bb_error_msg("Unknown video mode `%s'", mode);
-            return EXIT_FAILURE;
+            bb_error_msg_and_die("unknown video mode '%s'", mode);
         }
     }
 
     setmode(&var, &varset);
-    if (g_options & OPT_CHANGE)
-        if (ioctl(fh, FBIOPUT_VSCREENINFO, &var))
-            bb_perror_msg_and_die("fbset(ioctl)");
+    if (g_options & OPT_CHANGE) {
+        if (g_options & OPT_ALL)
+            var.activate = FB_ACTIVATE_ALL;
+        xioctl(fh, FBIOPUT_VSCREENINFO, &var);
+    }
     showmode(&var);
     /* Don't close the file, as exiting will take care of that */

branches/2.2.5/mindi-busybox/util-linux/fdformat.c

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /* fdformat.c  -  Low-level formats a floppy disk - Werner Almesberger */
 
@@ -9 +10 @@
  */
 
-#include <stdio.h>
-#include <string.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include "busybox.h"
+#include "libbb.h"
 
 
@@ -53 +46 @@
 #define FD_FILL_BYTE 0xF6 /* format fill byte. */
 
-static void print_and_flush(const char * __restrict format, ...)
-{
-    va_list arg;
-
-    va_start(arg, format);
-    bb_vfprintf(stdout, format, arg);
-    va_end(arg);
-    bb_xfflush_stdout();
-}
-
-static void bb_xioctl(int fd, int request, void *argp, const char *string)
-{
-    if (ioctl (fd, request, argp) < 0) {
-        bb_perror_msg_and_die(string);
-    }
-}
-
+int fdformat_main(int argc,char **argv);
 int fdformat_main(int argc,char **argv)
 {
@@ -81 +58 @@
         bb_show_usage();
     }
-    verify = !bb_getopt_ulflags(argc, argv, "n");
+    verify = !getopt32(argv, "n");
     argv += optind;
 
-    /* R_OK is needed for verifying */
-    if (stat(*argv,&st) < 0 || access(*argv,W_OK | R_OK ) < 0) {
-        bb_perror_msg_and_die("%s",*argv);
-    }
+    xstat(*argv, &st);
     if (!S_ISBLK(st.st_mode)) {
-        bb_error_msg_and_die("%s: not a block device",*argv);
+        bb_error_msg_and_die("%s: not a block device", *argv);
         /* do not test major - perhaps this was an USB floppy */
     }
 
+    /* O_RDWR for formatting and verifying */
+    fd = xopen(*argv, O_RDWR);
 
-    /* O_RDWR for formatting and verifying */
-    fd = bb_xopen(*argv,O_RDWR );
+    /* original message was: "Could not determine current format type" */
+    xioctl(fd, FDGETPRM, &param);
 
-    bb_xioctl(fd, FDGETPRM, &param, "FDGETPRM");/*original message was: "Could not determine current format type" */
-
-    print_and_flush("%s-sided, %d tracks, %d sec/track. Total capacity %d kB.\n",
+    printf("%s-sided, %d tracks, %d sec/track. Total capacity %d kB\n",
         (param.head == 2) ? "Double" : "Single",
         param.track, param.sect, param.size >> 1);
 
     /* FORMAT */
-    print_and_flush("Formatting ... ", NULL);
-    bb_xioctl(fd, FDFMTBEG,NULL,"FDFMTBEG");
+    printf("Formatting... ");
+    xioctl(fd, FDFMTBEG, NULL);
 
     /* n == track */
-    for (n = 0; n < param.track; n++)
-    {
-        descr.head = 0;
-        descr.track = n;
-        bb_xioctl(fd, FDFMTTRK,&descr,"FDFMTTRK");
-        print_and_flush("%3d\b\b\b", n);
-        if (param.head == 2) {
-        descr.head = 1;
-        bb_xioctl(fd, FDFMTTRK,&descr,"FDFMTTRK");
-        }
+    for (n = 0; n < param.track; n++) {
+        descr.head = 0;
+        descr.track = n;
+        xioctl(fd, FDFMTTRK, &descr);
+        printf("%3d\b\b\b", n);
+        if (param.head == 2) {
+            descr.head = 1;
+            xioctl(fd, FDFMTTRK, &descr);
+        }
     }
 
-    bb_xioctl(fd,FDFMTEND,NULL,"FDFMTEND");
-    print_and_flush("done\n", NULL);
+    xioctl(fd, FDFMTEND, NULL);
+    printf("done\n");
 
     /* VERIFY */
-    if(verify) {
+    if (verify) {
         /* n == cyl_size */
         n = param.sect*param.head*512;
 
         data = xmalloc(n);
-        print_and_flush("Verifying ... ", NULL);
+        printf("Verifying... ");
         for (cyl = 0; cyl < param.track; cyl++) {
-            print_and_flush("%3d\b\b\b", cyl);
-            if((read_bytes = safe_read(fd,data,n))!= n ) {
-                if(read_bytes < 0) {
+            printf("%3d\b\b\b", cyl);
+            read_bytes = safe_read(fd, data, n);
+            if (read_bytes != n) {
+                if (read_bytes < 0) {
                     bb_perror_msg(bb_msg_read_error);
                 }
-                bb_error_msg_and_die("Problem reading cylinder %d, expected %d, read %d", cyl, n, read_bytes);
+                bb_error_msg_and_die("problem reading cylinder %d, "
+                    "expected %d, read %d", cyl, n, read_bytes);
+                // FIXME: maybe better seek & continue??
             }
             /* Check backwards so we don't need a counter */
-            while(--read_bytes>=0) {
-                if( data[read_bytes] != FD_FILL_BYTE) {
-                     print_and_flush("bad data in cyl %d\nContinuing ... ",cyl);
+            while (--read_bytes >= 0) {
+                if (data[read_bytes] != FD_FILL_BYTE) {
+                     printf("bad data in cyl %d\nContinuing... ",cyl);
                 }
             }
@@ -151 +127 @@
         if (ENABLE_FEATURE_CLEAN_UP) free(data);
 
-        print_and_flush("done\n", NULL);
+        printf("done\n");
     }
 

branches/2.2.5/mindi-busybox/util-linux/fdisk.c

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /* fdisk.c -- Partition table manipulator for Linux.
  *
@@ -7 +8 @@
  */
 
-/* Current changes have not compatibility with this version */
-#define UTIL_LINUX_VERSION "2.12"
-
-
-#define _(x) x
-
-#define PROC_PARTITIONS "/proc/partitions"
-
-#include <features.h>
-#include <sys/types.h>
-#include <sys/stat.h>           /* stat */
-#include <ctype.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <setjmp.h>
+#ifndef _LARGEFILE64_SOURCE
+/* For lseek64 */
+#define _LARGEFILE64_SOURCE
+#endif
 #include <assert.h>             /* assert */
-#include <getopt.h>
-#include <endian.h>
-#include <sys/ioctl.h>
-#include <sys/param.h>
-#include <sys/sysmacros.h>     /* major */
-
-#include <stdint.h>        /* for uint32_t, uint16_t, uint8_t, int16_t, etc */
-
-/* Copied from linux/major.h */
-#define FLOPPY_MAJOR    2
-
-#include <sys/utsname.h>
-
-#include "busybox.h"
-
-#define DKTYPENAMES
-
-/*
-   fdisk.h
-*/
+#include "libbb.h"
+
+/* Looks like someone forgot to add this to config system */
+#ifndef ENABLE_FEATURE_FDISK_BLKSIZE
+# define ENABLE_FEATURE_FDISK_BLKSIZE 0
+# define USE_FEATURE_FDISK_BLKSIZE(a)
+#endif
 
 #define DEFAULT_SECTOR_SIZE     512
 #define MAX_SECTOR_SIZE 2048
-#define SECTOR_SIZE     512     /* still used in BSD code */
+#define SECTOR_SIZE     512     /* still used in osf/sgi/sun code */
 #define MAXIMUM_PARTS   60
 
@@ -64 +37 @@
 #define LINUX_RAID      0xfd
 
-#define SUNOS_SWAP 3
-#define WHOLE_DISK 5
-
-#define IS_EXTENDED(i) \
-    ((i) == EXTENDED || (i) == WIN98_EXTENDED || (i) == LINUX_EXTENDED)
-
-#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)
-
-#ifdef CONFIG_FEATURE_SUN_LABEL
-#define SCSI_IOCTL_GET_IDLUN 0x5382
-#endif
-
-
-/* including <linux/hdreg.h> also fails */
+/* Used for sector numbers. Today's disk sizes make it necessary */
+typedef unsigned long long ullong;
+
 struct hd_geometry {
     unsigned char heads;
@@ -88 +47 @@
 };
 
-#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;
-
-/*
- * 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
+#define HDIO_GETGEO     0x0301  /* get device geometry */
+
+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";
+
+static const char msg_part_already_defined[] ALIGN1 =
+"Partition %d is already defined, delete it before re-adding\n";
+
+
+static unsigned sector_size = DEFAULT_SECTOR_SIZE;
+static unsigned user_set_sector_size;
+static unsigned sector_offset = 1;
+
+#if ENABLE_FEATURE_OSF_LABEL
 static int possibly_osf_label;
 #endif
 
-static uint heads, sectors, cylinders;
+static unsigned heads, sectors, cylinders;
 static void update_units(void);
 
-
-/*
- * 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 {
@@ -169 +83 @@
 } ATTRIBUTE_PACKED;
 
-enum failure {
-    ioctl_error, unable_to_open, unable_to_read, unable_to_seek,
-    unable_to_write
-};
-
-enum label_type{
+static const char unable_to_open[] ALIGN1 = "cannot open %s";
+static const char unable_to_read[] ALIGN1 = "cannot read from %s";
+static const char unable_to_seek[] ALIGN1 = "cannot seek on %s";
+static const char unable_to_write[] ALIGN1 = "cannot write to %s";
+static const char ioctl_error[] ALIGN1 = "BLKGETSIZE ioctl failed on %s";
+static void fdisk_fatal(const char *why) ATTRIBUTE_NORETURN;
+
+enum label_type {
     label_dos, label_sun, label_sgi, label_aix, label_osf
 };
+
+#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
+
+#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
+
+#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
+
+#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
 
 enum action { fdisk, require, try_only, create_empty_dos, create_empty_sun };
@@ -185 +135 @@
 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 char *line_ptr;
+static int display_in_cyl_units = 1;
+static unsigned units_per_sector = 1;
+#if ENABLE_FEATURE_FDISK_WRITABLE
 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 void list_types(const char *const *sys);
+static unsigned read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg);
 #endif
 static const char *partition_type(unsigned char type);
-static void fdisk_fatal(enum failure why) ATTRIBUTE_NORETURN;
 static void get_geometry(void);
 static int get_boot(enum action what);
@@ -204 +152 @@
 #define SINGULAR 1
 
-#define hex_val(c)      ({ \
-                char _c = (c); \
-                isdigit(_c) ? _c - '0' : \
-                tolower(_c) + 10 - 'a'; \
-            })
-
-
-#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))
-
-#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 int32_t get_start_sect(const struct partition *p);
-static int32_t get_nr_sects(const struct partition *p);
+static unsigned get_start_sect(const struct partition *p);
+static unsigned get_nr_sects(const struct partition *p);
 
 /*
@@ -240 +163 @@
  * partition and one link to the next one.
  */
-static struct pte {
+struct pte {
     struct partition *part_table;   /* points into sectorbuffer */
     struct partition *ext_pointer;  /* points into sectorbuffer */
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+    ullong offset;          /* disk sector number */
+    char *sectorbuffer;     /* disk sector contents */
+#if ENABLE_FEATURE_FDISK_WRITABLE
     char changed;           /* boolean */
 #endif
-    off_t offset;            /* disk sector number */
-    char *sectorbuffer;     /* disk sector contents */
-} ptes[MAXIMUM_PARTS];
-
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+};
+
+/* DOS partition types */
+
+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
+};
+
+
+/* Globals */
+
+struct globals {
+    char *line_ptr;
+    char line_buffer[80];
+    char partname_buffer[80];
+    jmp_buf listingbuf;
+    /* 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];
+};
+/* bb_common_bufsiz1 is too small for this on 64 bit CPUs */
+#define G (*ptr_to_globals)
+
+#define line_ptr        (G.line_ptr)
+#define listingbuf      (G.listingbuf)
+#define line_buffer     (G.line_buffer)
+#define partname_buffer (G.partname_buffer)
+#define MBRbuffer       (G.MBRbuffer)
+#define ptes            (G.ptes)
+
+
+/* Code */
+
+#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)))
+
+#define set_hsc(h,s,c,sector) \
+    do { \
+        s = sector % sectors + 1;  \
+        sector /= sectors;         \
+        h = sector % heads;        \
+        sector /= heads;           \
+        c = sector & 0xff;         \
+        s |= (sector >> 2) & 0xc0; \
+    } while (0)
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
+/* read line; return 0 or first printable char */
+static int
+read_line(const char *prompt)
+{
+    int sz;
+
+    sz = read_line_input(prompt, line_buffer, sizeof(line_buffer), NULL);
+    if (sz <= 0)
+        exit(0); /* Ctrl-D or Ctrl-C */
+
+    if (line_buffer[sz-1] == '\n')
+        line_buffer[--sz] = '\0';
+
+    line_ptr = line_buffer;
+    while (*line_ptr && !isgraph(*line_ptr))
+        line_ptr++;
+    return *line_ptr;
+}
+#endif
+
+/*
+ * return partition name - uses static storage
+ */
+static const char *
+partname(const char *dev, int pno, int lth)
+{
+    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;
+}
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
 static void
 set_all_unchanged(void)
@@ -261 +401 @@
 }
 
-static void
+static ALWAYS_INLINE void
 set_changed(int i)
 {
     ptes[i].changed = 1;
 }
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-
-#if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_OSF_LABEL)
-static struct partition *
+#endif /* FEATURE_FDISK_WRITABLE */
+
+static ALWAYS_INLINE struct partition *
 get_part_table(int i)
 {
     return ptes[i].part_table;
 }
-#endif
 
 static const char *
@@ -280 +418 @@
 {      /* 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) {
-    const unsigned char *b = (const unsigned char *)mbuffer;
-    return (b[510] == 0x55 && b[511] == 0xaa);
-}
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static char  line_buffer[LINE_LENGTH];
-
-/* read line; return 0 or first char */
+valid_part_table_flag(const char *mbuffer)
+{
+    return (mbuffer[510] == 0x55 && (uint8_t)mbuffer[511] == 0xaa);
+}
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static ALWAYS_INLINE void
+write_part_table_flag(char *b)
+{
+    b[510] = 0x55;
+    b[511] = 0xaa;
+}
+
+static char
+read_nonempty(const char *mesg)
+{
+    while (!read_line(mesg)) /* repeat */;
+    return *line_ptr;
+}
+
+static char
+read_maybe_empty(const char *mesg)
+{
+    if (!read_line(mesg)) {
+        line_ptr = line_buffer;
+        line_ptr[0] = '\n';
+        line_ptr[1] = '\0';
+    }
+    return line_ptr[0];
+}
+
 static int
-read_line(void)
-{
-    static int got_eof = 0;
-
-    fflush (stdout);         /* requested by niles@scyld.com */
-    line_ptr = line_buffer;
-    if (!fgets(line_buffer, LINE_LENGTH, stdin)) {
-        if (feof(stdin))
-            got_eof++;      /* user typed ^D ? */
-        if (got_eof >= 3) {
-            fprintf(stderr, _("\ngot EOF thrice - exiting..\n"));
-            exit(1);
-        }
-        return 0;
-    }
-    while (*line_ptr && !isgraph(*line_ptr))
-        line_ptr++;
-    return *line_ptr;
-}
-
-static char
-read_char(const char *mesg)
-{
-    do {
-        fputs(mesg, stdout);
-    } while (!read_line());
-    return *line_ptr;
-}
-
-static char
-read_chars(const char *mesg)
-{
-    fputs(mesg, stdout);
-    if (!read_line()) {
-        *line_ptr = '\n';
-        line_ptr[1] = 0;
-    }
-    return *line_ptr;
-}
-
-static int
-read_hex(const struct systypes *sys)
-{
-    int hex;
-
+read_hex(const char *const *sys)
+{
+    unsigned long v;
     while (1) {
-        read_char(_("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 == 'l' || *line_ptr == 'L') {
             list_types(sys);
-        else if (isxdigit (*line_ptr)) {
-            hex = 0;
-            do
-                hex = hex << 4 | hex_val(*line_ptr++);
-            while (isxdigit(*line_ptr));
-            return hex;
-        }
-    }
-}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-
-#ifdef CONFIG_FEATURE_AIX_LABEL
-/*
- * Copyright (C) Andreas Neuper, Sep 1998.
- *      This file may be redistributed under
- *      the terms of the GNU Public License.
- */
-
-typedef struct {
-    unsigned int   magic;        /* expect AIX_LABEL_MAGIC */
-    unsigned int   fillbytes1[124];
-    unsigned int   physical_volume_id;
-    unsigned int   fillbytes2[124];
-} aix_partition;
-
-#define AIX_LABEL_MAGIC         0xc9c2d4c1
-#define AIX_LABEL_MAGIC_SWAPPED 0xc1d4c2c9
-#define AIX_INFO_MAGIC          0x00072959
-#define AIX_INFO_MAGIC_SWAPPED  0x59290700
-
-#define aixlabel ((aix_partition *)MBRbuffer)
-
-
-/*
-  Changes:
-  * 1999-03-20 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
-  *     Internationalization
-  *
-  * 2003-03-20 Phillip Kesling <pkesling@sgi.com>
-  *      Some fixes
-*/
-
-static int aix_other_endian;
-static short aix_volumes = 1;
-
-/*
- * only dealing with free blocks here
- */
-
-static void
-aix_info(void)
-{
-    puts(
-        _("\n\tThere is a valid AIX label on this disk.\n"
-        "\tUnfortunately Linux cannot handle these\n"
-        "\tdisks at the moment.  Nevertheless some\n"
-        "\tadvice:\n"
-        "\t1. fdisk will destroy its contents on write.\n"
-        "\t2. Be sure that this disk is NOT a still vital\n"
-        "\t   part of a volume group. (Otherwise you may\n"
-        "\t   erase the other disks as well, if unmirrored.)\n"
-        "\t3. Before deleting this physical volume be sure\n"
-        "\t   to remove the disk logically from your AIX\n"
-        "\t   machine.  (Otherwise you become an AIXpert).")
-    );
-}
-
-static int
-check_aix_label(void)
-{
-    if (aixlabel->magic != AIX_LABEL_MAGIC &&
-        aixlabel->magic != AIX_LABEL_MAGIC_SWAPPED) {
-        current_label_type = 0;
-        aix_other_endian = 0;
-        return 0;
-    }
-    aix_other_endian = (aixlabel->magic == AIX_LABEL_MAGIC_SWAPPED);
-    update_units();
-    current_label_type = label_aix;
-    partitions = 1016;
-    aix_volumes = 15;
-    aix_info();
-    /*aix_nolabel();*/              /* %% */
-    /*aix_label = 1;*/              /* %% */
-    return 1;
-}
-#endif  /* AIX_LABEL */
-
-#ifdef CONFIG_FEATURE_OSF_LABEL
-/*
- * Copyright (c) 1987, 1988 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgment:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-
-#ifndef BSD_DISKMAGIC
-#define BSD_DISKMAGIC     ((uint32_t) 0x82564557)
-#endif
-
-#ifndef BSD_MAXPARTITIONS
-#define BSD_MAXPARTITIONS 16
-#endif
-
-#define BSD_LINUX_BOOTDIR "/usr/ucb/mdec"
-
-#if defined (i386) || defined (__sparc__) || defined (__arm__) || defined (__m68k__) || defined (__mips__) || defined (__s390__) || defined (__sh__) || defined(__x86_64__)
-#define BSD_LABELSECTOR   1
-#define BSD_LABELOFFSET   0
-#elif defined (__alpha__) || defined (__powerpc__) || defined (__ia64__) || defined (__hppa__)
-#define BSD_LABELSECTOR   0
-#define BSD_LABELOFFSET   64
-#elif defined (__s390__) || defined (__s390x__)
-#define BSD_LABELSECTOR   1
-#define BSD_LABELOFFSET   0
-#else
-#error unknown architecture
-#endif
-
-#define BSD_BBSIZE        8192          /* size of boot area, with label */
-#define BSD_SBSIZE        8192          /* max size of fs superblock */
-
-struct xbsd_disklabel {
-    uint32_t   d_magic;                /* the magic number */
-    int16_t    d_type;                 /* drive type */
-    int16_t    d_subtype;              /* controller/d_type specific */
-    char       d_typename[16];         /* type name, e.g. "eagle" */
-    char       d_packname[16];                 /* pack identifier */
-            /* disk geometry: */
-    uint32_t   d_secsize;              /* # of bytes per sector */
-    uint32_t   d_nsectors;             /* # of data sectors per track */
-    uint32_t   d_ntracks;              /* # of tracks per cylinder */
-    uint32_t   d_ncylinders;           /* # of data cylinders per unit */
-    uint32_t   d_secpercyl;            /* # of data sectors per cylinder */
-    uint32_t   d_secperunit;           /* # of data sectors per unit */
-    /*
-     * Spares (bad sector replacements) below
-     * are not counted in d_nsectors or d_secpercyl.
-     * Spare sectors are assumed to be physical sectors
-     * which occupy space at the end of each track and/or cylinder.
-     */
-    uint16_t   d_sparespertrack;       /* # of spare sectors per track */
-    uint16_t   d_sparespercyl;         /* # of spare sectors per cylinder */
-    /*
-     * Alternate cylinders include maintenance, replacement,
-     * configuration description areas, etc.
-     */
-    uint32_t   d_acylinders;           /* # of alt. cylinders per unit */
-
-            /* hardware characteristics: */
-    /*
-     * d_interleave, d_trackskew and d_cylskew describe perturbations
-     * in the media format used to compensate for a slow controller.
-     * Interleave is physical sector interleave, set up by the formatter
-     * or controller when formatting.  When interleaving is in use,
-     * logically adjacent sectors are not physically contiguous,
-     * but instead are separated by some number of sectors.
-     * It is specified as the ratio of physical sectors traversed
-     * per logical sector.  Thus an interleave of 1:1 implies contiguous
-     * layout, while 2:1 implies that logical sector 0 is separated
-     * by one sector from logical sector 1.
-     * d_trackskew is the offset of sector 0 on track N
-     * relative to sector 0 on track N-1 on the same cylinder.
-     * Finally, d_cylskew is the offset of sector 0 on cylinder N
-     * relative to sector 0 on cylinder N-1.
-     */
-    uint16_t   d_rpm;                  /* rotational speed */
-    uint16_t   d_interleave;           /* hardware sector interleave */
-    uint16_t   d_trackskew;            /* sector 0 skew, per track */
-    uint16_t   d_cylskew;              /* sector 0 skew, per cylinder */
-    uint32_t   d_headswitch;           /* head switch time, usec */
-    uint32_t   d_trkseek;              /* track-to-track seek, usec */
-    uint32_t   d_flags;                /* generic flags */
-#define NDDATA 5
-    uint32_t   d_drivedata[NDDATA];    /* drive-type specific information */
-#define NSPARE 5
-    uint32_t   d_spare[NSPARE];        /* reserved for future use */
-    uint32_t   d_magic2;               /* the magic number (again) */
-    uint16_t   d_checksum;             /* xor of data incl. partitions */
-            /* filesystem and partition information: */
-    uint16_t   d_npartitions;          /* number of partitions in following */
-    uint32_t   d_bbsize;               /* size of boot area at sn0, bytes */
-    uint32_t   d_sbsize;               /* max size of fs superblock, bytes */
-    struct xbsd_partition    {      /* the partition table */
-        uint32_t   p_size;         /* number of sectors in partition */
-        uint32_t   p_offset;       /* starting sector */
-        uint32_t   p_fsize;        /* filesystem basic fragment size */
-        uint8_t    p_fstype;       /* filesystem type, see below */
-        uint8_t    p_frag;         /* filesystem fragments per block */
-        uint16_t   p_cpg;          /* filesystem cylinders per group */
-    } d_partitions[BSD_MAXPARTITIONS]; /* actually may be more */
-};
-
-/* d_type values: */
-#define BSD_DTYPE_SMD           1               /* SMD, XSMD; VAX hp/up */
-#define BSD_DTYPE_MSCP          2               /* MSCP */
-#define BSD_DTYPE_DEC           3               /* other DEC (rk, rl) */
-#define BSD_DTYPE_SCSI          4               /* SCSI */
-#define BSD_DTYPE_ESDI          5               /* ESDI interface */
-#define BSD_DTYPE_ST506         6               /* ST506 etc. */
-#define BSD_DTYPE_HPIB          7               /* CS/80 on HP-IB */
-#define BSD_DTYPE_HPFL          8               /* HP Fiber-link */
-#define BSD_DTYPE_FLOPPY        10              /* floppy */
-
-/* d_subtype values: */
-#define BSD_DSTYPE_INDOSPART    0x8             /* is inside dos partition */
-#define BSD_DSTYPE_DOSPART(s)   ((s) & 3)       /* dos partition number */
-#define BSD_DSTYPE_GEOMETRY     0x10            /* drive params in label */
-
-#ifdef DKTYPENAMES
-static const char * const xbsd_dktypenames[] = {
-    "unknown",
-    "SMD",
-    "MSCP",
-    "old DEC",
-    "SCSI",
-    "ESDI",
-    "ST506",
-    "HP-IB",
-    "HP-FL",
-    "type 9",
-    "floppy",
-    0
-};
-#define BSD_DKMAXTYPES  (sizeof(xbsd_dktypenames) / sizeof(xbsd_dktypenames[0]) - 1)
-#endif
-
-/*
- * Filesystem type and version.
- * Used to interpret other filesystem-specific
- * per-partition information.
- */
-#define BSD_FS_UNUSED   0               /* unused */
-#define BSD_FS_SWAP     1               /* swap */
-#define BSD_FS_V6       2               /* Sixth Edition */
-#define BSD_FS_V7       3               /* Seventh Edition */
-#define BSD_FS_SYSV     4               /* System V */
-#define BSD_FS_V71K     5               /* V7 with 1K blocks (4.1, 2.9) */
-#define BSD_FS_V8       6               /* Eighth Edition, 4K blocks */
-#define BSD_FS_BSDFFS   7               /* 4.2BSD fast file system */
-#define BSD_FS_BSDLFS   9               /* 4.4BSD log-structured file system */
-#define BSD_FS_OTHER    10              /* in use, but unknown/unsupported */
-#define BSD_FS_HPFS     11              /* OS/2 high-performance file system */
-#define BSD_FS_ISO9660  12              /* ISO-9660 filesystem (cdrom) */
-#define BSD_FS_ISOFS    BSD_FS_ISO9660
-#define BSD_FS_BOOT     13              /* partition contains bootstrap */
-#define BSD_FS_ADOS     14              /* AmigaDOS fast file system */
-#define BSD_FS_HFS      15              /* Macintosh HFS */
-#define BSD_FS_ADVFS    16              /* Digital Unix AdvFS */
-
-/* this is annoying, but it's also the way it is :-( */
-#ifdef __alpha__
-#define BSD_FS_EXT2     8               /* ext2 file system */
-#else
-#define BSD_FS_MSDOS    8               /* MS-DOS file system */
-#endif
-
-#ifdef  DKTYPENAMES
-static const struct systypes xbsd_fstypes[] = {
-    { "\x00" "unused" },            /* BSD_FS_UNUSED  */
-    { "\x01" "swap" },              /* BSD_FS_SWAP    */
-    { "\x02" "Version 6" },         /* BSD_FS_V6      */
-    { "\x03" "Version 7" },         /* BSD_FS_V7      */
-    { "\x04" "System V" },          /* BSD_FS_SYSV    */
-    { "\x05" "4.1BSD" },            /* BSD_FS_V71K    */
-    { "\x06" "Eighth Edition" },    /* BSD_FS_V8      */
-    { "\x07" "4.2BSD" },            /* BSD_FS_BSDFFS  */
-#ifdef __alpha__
-    { "\x08" "ext2" },              /* BSD_FS_EXT2    */
-#else
-    { "\x08" "MS-DOS" },            /* BSD_FS_MSDOS   */
-#endif
-    { "\x09" "4.4LFS" },            /* BSD_FS_BSDLFS  */
-    { "\x0a" "unknown" },           /* BSD_FS_OTHER   */
-    { "\x0b" "HPFS" },              /* BSD_FS_HPFS    */
-    { "\x0c" "ISO-9660" },          /* BSD_FS_ISO9660 */
-    { "\x0d" "boot" },              /* BSD_FS_BOOT    */
-    { "\x0e" "ADOS" },              /* BSD_FS_ADOS    */
-    { "\x0f" "HFS" },               /* BSD_FS_HFS     */
-    { "\x10" "AdvFS" },             /* BSD_FS_ADVFS   */
-    { NULL }
-};
-#define BSD_FSMAXTYPES (SIZE(xbsd_fstypes)-1)
-
-#endif
-
-/*
- * flags shared by various drives:
- */
-#define BSD_D_REMOVABLE 0x01            /* removable media */
-#define BSD_D_ECC       0x02            /* supports ECC */
-#define BSD_D_BADSECT   0x04            /* supports bad sector forw. */
-#define BSD_D_RAMDISK   0x08            /* disk emulator */
-#define BSD_D_CHAIN     0x10            /* can do back-back transfers */
-#define BSD_D_DOSPART   0x20            /* within MSDOS partition */
-
-#endif /* OSF_LABEL */
-
-/*
- * Copyright (C) Andreas Neuper, Sep 1998.
- *      This file may be modified and redistributed under
- *      the terms of the GNU Public License.
- */
-
-struct device_parameter { /* 48 bytes */
-    unsigned char  skew;
-    unsigned char  gap1;
-    unsigned char  gap2;
-    unsigned char  sparecyl;
-    unsigned short pcylcount;
-    unsigned short head_vol0;
-    unsigned short ntrks;   /* tracks in cyl 0 or vol 0 */
-    unsigned char  cmd_tag_queue_depth;
-    unsigned char  unused0;
-    unsigned short unused1;
-    unsigned short nsect;   /* sectors/tracks in cyl 0 or vol 0 */
-    unsigned short bytes;
-    unsigned short ilfact;
-    unsigned int   flags;           /* controller flags */
-    unsigned int   datarate;
-    unsigned int   retries_on_error;
-    unsigned int   ms_per_word;
-    unsigned short xylogics_gap1;
-    unsigned short xylogics_syncdelay;
-    unsigned short xylogics_readdelay;
-    unsigned short xylogics_gap2;
-    unsigned short xylogics_readgate;
-    unsigned short xylogics_writecont;
-};
-
-#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 ENTIRE_DISK     SGI_VOLUME
-/*
- * controller flags
- */
-#define SECTOR_SLIP     0x01
-#define SECTOR_FWD      0x02
-#define TRACK_FWD       0x04
-#define TRACK_MULTIVOL  0x08
-#define IGNORE_ERRORS   0x10
-#define RESEEK          0x20
-#define ENABLE_CMDTAGQ  0x40
-
-typedef struct {
-    unsigned int   magic;            /* expect SGI_LABEL_MAGIC */
-    unsigned short boot_part;        /* active boot partition */
-    unsigned short swap_part;        /* active swap partition */
-    unsigned char  boot_file[16];    /* name of the bootfile */
-    struct device_parameter devparam;       /*  1 * 48 bytes */
-    struct volume_directory {               /* 15 * 16 bytes */
-        unsigned char vol_file_name[8]; /* a character array */
-        unsigned int  vol_file_start;   /* number of logical block */
-        unsigned int  vol_file_size;    /* number of bytes */
-    } directory[15];
-    struct sgi_partition {                  /* 16 * 12 bytes */
-        unsigned int num_sectors;       /* number of blocks */
-        unsigned int start_sector;      /* must be cylinder aligned */
-        unsigned int id;
-    } partitions[16];
-    unsigned int   csum;
-    unsigned int   fillbytes;
-} sgi_partition;
-
-typedef struct {
-    unsigned int   magic;           /* looks like a magic number */
-    unsigned int   a2;
-    unsigned int   a3;
-    unsigned int   a4;
-    unsigned int   b1;
-    unsigned short b2;
-    unsigned short b3;
-    unsigned int   c[16];
-    unsigned short d[3];
-    unsigned char  scsi_string[50];
-    unsigned char  serial[137];
-    unsigned short check1816;
-    unsigned char  installer[225];
-} sgiinfo;
-
-#define SGI_LABEL_MAGIC         0x0be5a941
-#define SGI_LABEL_MAGIC_SWAPPED 0x41a9e50b
-#define SGI_INFO_MAGIC          0x00072959
-#define SGI_INFO_MAGIC_SWAPPED  0x59290700
-#define SGI_SSWAP16(x) (sgi_other_endian ? __swap16(x) \
-                 : (uint16_t)(x))
-#define SGI_SSWAP32(x) (sgi_other_endian ? __swap32(x) \
-                 : (uint32_t)(x))
-
-#define sgilabel ((sgi_partition *)MBRbuffer)
-#define sgiparam (sgilabel->devparam)
+            continue;
+        }
+        v = bb_strtoul(line_ptr, NULL, 16);
+        if (v > 0xff)
+            /* Bad input also triggers this */
+            continue;
+        return v;
+    }
+}
+#endif /* FEATURE_FDISK_WRITABLE */
+
+#include "fdisk_aix.c"
 
 typedef struct {
@@ -794 +495 @@
     unsigned short nsect;      /* Sectors per track */
     unsigned char spare3[4];   /* Even more magic... */
-    struct sun_partition {
+    struct sun_partinfo {
         uint32_t start_cylinder;
         uint32_t num_sectors;
@@ -801 +502 @@
     unsigned short csum;       /* Label xor'd checksum */
 } sun_partition;
-
-
-#define SUN_LABEL_MAGIC          0xDABE
-#define SUN_LABEL_MAGIC_SWAPPED  0xBEDA
 #define sunlabel ((sun_partition *)MBRbuffer)
-#define SUN_SSWAP16(x) (sun_other_endian ? __swap16(x) \
-                 : (uint16_t)(x))
-#define SUN_SSWAP32(x) (sun_other_endian ? __swap32(x) \
-                 : (uint32_t)(x))
-
-
-#ifdef CONFIG_FEATURE_OSF_LABEL
-/*
-   Changes:
-   19990319 - Arnaldo Carvalho de Melo <acme@conectiva.com.br> - i18n/nls
-
-   20000101 - David Huggins-Daines <dhuggins@linuxcare.com> - Better
-   support for OSF/1 disklabels on Alpha.
-   Also fixed unaligned accesses in alpha_bootblock_checksum()
-*/
-
-#define FREEBSD_PARTITION       0xa5
-#define NETBSD_PARTITION        0xa9
-
-static void xbsd_delete_part(void);
-static void xbsd_new_part(void);
-static void xbsd_write_disklabel(void);
-static int xbsd_create_disklabel(void);
-static void xbsd_edit_disklabel(void);
-static void xbsd_write_bootstrap(void);
-static void xbsd_change_fstype(void);
-static int xbsd_get_part_index(int max);
-static int xbsd_check_new_partition(int *i);
-static void xbsd_list_types(void);
-static u_short xbsd_dkcksum(struct xbsd_disklabel *lp);
-static int xbsd_initlabel(struct partition *p, struct xbsd_disklabel *d);
-static int xbsd_readlabel(struct partition *p, struct xbsd_disklabel *d);
-static int xbsd_writelabel(struct partition *p, struct xbsd_disklabel *d);
-
-#if defined (__alpha__)
-static void alpha_bootblock_checksum(char *boot);
-#endif
-
-#if !defined (__alpha__)
-static int xbsd_translate_fstype(int linux_type);
-static void xbsd_link_part(void);
-static struct partition *xbsd_part;
-static int xbsd_part_index;
-#endif
-
-#if defined (__alpha__)
-/* We access this through a uint64_t * when checksumming */
-static char disklabelbuffer[BSD_BBSIZE] ATTRIBUTE_ALIGNED(8);
-#else
-static char disklabelbuffer[BSD_BBSIZE];
-#endif
-
-static struct xbsd_disklabel xbsd_dlabel;
-
-#define bsd_cround(n) \
-    (display_in_cyl_units ? ((n)/xbsd_dlabel.d_secpercyl) + 1 : (n))
-
-/*
- * Test whether the whole disk has BSD disk label magic.
- *
- * Note: often reformatting with DOS-type label leaves the BSD magic,
- * so this does not mean that there is a BSD disk label.
- */
-static int
-check_osf_label(void)
-{
-    if (xbsd_readlabel(NULL, &xbsd_dlabel) == 0)
-        return 0;
-    return 1;
-}
-
-static void xbsd_print_disklabel(int);
-
-static int
-btrydev(const char * dev)
-{
-    if (xbsd_readlabel (NULL, &xbsd_dlabel) == 0)
-        return -1;
-    printf(_("\nBSD label for device: %s\n"), dev);
-    xbsd_print_disklabel (0);
-    return 0;
-}
-
-static void
-bmenu(void)
-{
-    puts (_("Command action"));
-    puts (_("\td\tdelete a BSD partition"));
-    puts (_("\te\tedit drive data"));
-    puts (_("\ti\tinstall bootstrap"));
-    puts (_("\tl\tlist known filesystem types"));
-    puts (_("\tm\tprint this menu"));
-    puts (_("\tn\tadd a new BSD partition"));
-    puts (_("\tp\tprint BSD partition table"));
-    puts (_("\tq\tquit without saving changes"));
-    puts (_("\tr\treturn to main menu"));
-    puts (_("\ts\tshow complete disklabel"));
-    puts (_("\tt\tchange a partition's filesystem id"));
-    puts (_("\tu\tchange units (cylinders/sectors)"));
-    puts (_("\tw\twrite disklabel to disk"));
-#if !defined (__alpha__)
-    puts (_("\tx\tlink BSD partition to non-BSD partition"));
-#endif
-}
-
-#if !defined (__alpha__)
-static int
-hidden(int type)
-{
-    return type ^ 0x10;
-}
-
-static int
-is_bsd_partition_type(int type)
-{
-    return (type == FREEBSD_PARTITION ||
-        type == hidden(FREEBSD_PARTITION) ||
-        type == NETBSD_PARTITION ||
-        type == hidden(NETBSD_PARTITION));
-}
-#endif
-
-static void
-bselect(void)
-{
-#if !defined (__alpha__)
-    int t, ss;
-    struct partition *p;
-
-    for (t = 0; t < 4; t++) {
-        p = get_part_table(t);
-        if (p && is_bsd_partition_type(p->sys_ind)) {
-            xbsd_part = p;
-            xbsd_part_index = t;
-            ss = get_start_sect(xbsd_part);
-            if (ss == 0) {
-                fprintf(stderr, _("Partition %s has invalid starting sector 0.\n"),
-                    partname(disk_device, t+1, 0));
-                return;
-            }
-                printf(_("Reading disklabel of %s at sector %d.\n"),
-                    partname(disk_device, t+1, 0), ss + BSD_LABELSECTOR);
-            if (xbsd_readlabel(xbsd_part, &xbsd_dlabel) == 0)
-                if (xbsd_create_disklabel() == 0)
-                    return;
-                break;
-        }
-    }
-
-    if (t == 4) {
-        printf(_("There is no *BSD partition on %s.\n"), disk_device);
-        return;
-    }
-
-#elif defined (__alpha__)
-
-    if (xbsd_readlabel(NULL, &xbsd_dlabel) == 0)
-        if (xbsd_create_disklabel() == 0)
-            exit (EXIT_SUCCESS);
-
-#endif
-
-    while (1) {
-        putchar('\n');
-        switch (tolower(read_char(_("BSD disklabel command (m for help): ")))) {
-        case 'd':
-            xbsd_delete_part();
-            break;
-        case 'e':
-            xbsd_edit_disklabel();
-            break;
-        case 'i':
-            xbsd_write_bootstrap();
-            break;
-        case 'l':
-            xbsd_list_types();
-            break;
-        case 'n':
-            xbsd_new_part();
-            break;
-        case 'p':
-            xbsd_print_disklabel(0);
-            break;
-        case 'q':
-            close(fd);
-            exit(EXIT_SUCCESS);
-        case 'r':
-            return;
-        case 's':
-            xbsd_print_disklabel(1);
-            break;
-        case 't':
-            xbsd_change_fstype();
-            break;
-        case 'u':
-            change_units();
-            break;
-        case 'w':
-            xbsd_write_disklabel();
-            break;
-#if !defined (__alpha__)
-        case 'x':
-            xbsd_link_part();
-            break;
-#endif
-        default:
-            bmenu();
-            break;
-        }
-    }
-}
-
-static void
-xbsd_delete_part(void)
-{
-    int i;
-
-    i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
-    xbsd_dlabel.d_partitions[i].p_size   = 0;
-    xbsd_dlabel.d_partitions[i].p_offset = 0;
-    xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
-    if (xbsd_dlabel.d_npartitions == i + 1)
-        while (xbsd_dlabel.d_partitions[xbsd_dlabel.d_npartitions-1].p_size == 0)
-            xbsd_dlabel.d_npartitions--;
-}
-
-static void
-xbsd_new_part(void)
-{
-    off_t begin, end;
-    char mesg[256];
-    int i;
-
-    if (!xbsd_check_new_partition(&i))
-        return;
-
-#if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__)
-    begin = get_start_sect(xbsd_part);
-    end = begin + get_nr_sects(xbsd_part) - 1;
-#else
-    begin = 0;
-    end = xbsd_dlabel.d_secperunit - 1;
-#endif
-
-    snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
-    begin = read_int(bsd_cround(begin), bsd_cround(begin), bsd_cround(end),
-        0, mesg);
-
-    if (display_in_cyl_units)
-        begin = (begin - 1) * xbsd_dlabel.d_secpercyl;
-
-    snprintf(mesg, sizeof(mesg), _("Last %s or +size or +sizeM or +sizeK"),
-        str_units(SINGULAR));
-    end = read_int(bsd_cround (begin), bsd_cround (end), bsd_cround (end),
-        bsd_cround (begin), mesg);
-
-    if (display_in_cyl_units)
-        end = end * xbsd_dlabel.d_secpercyl - 1;
-
-    xbsd_dlabel.d_partitions[i].p_size   = end - begin + 1;
-    xbsd_dlabel.d_partitions[i].p_offset = begin;
-    xbsd_dlabel.d_partitions[i].p_fstype = BSD_FS_UNUSED;
-}
-
-static void
-xbsd_print_disklabel(int show_all)
-{
-    struct xbsd_disklabel *lp = &xbsd_dlabel;
-    struct xbsd_partition *pp;
-    int i, j;
-
-    if (show_all) {
-#if defined (__alpha__)
-        printf("# %s:\n", disk_device);
-#else
-        printf("# %s:\n", partname(disk_device, xbsd_part_index+1, 0));
-#endif
-        if ((unsigned) lp->d_type < BSD_DKMAXTYPES)
-            printf(_("type: %s\n"), xbsd_dktypenames[lp->d_type]);
-        else
-            printf(_("type: %d\n"), lp->d_type);
-        printf(_("disk: %.*s\n"), (int) sizeof(lp->d_typename), lp->d_typename);
-        printf(_("label: %.*s\n"), (int) sizeof(lp->d_packname), lp->d_packname);
-        printf(_("flags:"));
-        if (lp->d_flags & BSD_D_REMOVABLE)
-            printf(_(" removable"));
-        if (lp->d_flags & BSD_D_ECC)
-            printf(_(" ecc"));
-        if (lp->d_flags & BSD_D_BADSECT)
-            printf(_(" badsect"));
-        printf("\n");
-        /* On various machines the fields of *lp are short/int/long */
-        /* In order to avoid problems, we cast them all to long. */
-        printf(_("bytes/sector: %ld\n"), (long) lp->d_secsize);
-        printf(_("sectors/track: %ld\n"), (long) lp->d_nsectors);
-        printf(_("tracks/cylinder: %ld\n"), (long) lp->d_ntracks);
-        printf(_("sectors/cylinder: %ld\n"), (long) lp->d_secpercyl);
-        printf(_("cylinders: %ld\n"), (long) lp->d_ncylinders);
-        printf(_("rpm: %d\n"), lp->d_rpm);
-        printf(_("interleave: %d\n"), lp->d_interleave);
-        printf(_("trackskew: %d\n"), lp->d_trackskew);
-        printf(_("cylinderskew: %d\n"), lp->d_cylskew);
-        printf(_("headswitch: %ld\t\t# milliseconds\n"),
-            (long) lp->d_headswitch);
-        printf(_("track-to-track seek: %ld\t# milliseconds\n"),
-            (long) lp->d_trkseek);
-        printf(_("drivedata: "));
-        for (i = NDDATA - 1; i >= 0; i--)
-            if (lp->d_drivedata[i])
-                break;
-        if (i < 0)
-            i = 0;
-        for (j = 0; j <= i; j++)
-            printf("%ld ", (long) lp->d_drivedata[j]);
-    }
-    printf(_("\n%d partitions:\n"), lp->d_npartitions);
-    printf(_("#       start       end      size     fstype   [fsize bsize   cpg]\n"));
-    pp = lp->d_partitions;
-    for (i = 0; i < lp->d_npartitions; i++, pp++) {
-        if (pp->p_size) {
-            if (display_in_cyl_units && lp->d_secpercyl) {
-                printf("  %c: %8ld%c %8ld%c %8ld%c  ",
-                    'a' + i,
-                    (long) pp->p_offset / lp->d_secpercyl + 1,
-                    (pp->p_offset % lp->d_secpercyl) ? '*' : ' ',
-                    (long) (pp->p_offset + pp->p_size + lp->d_secpercyl - 1) / lp->d_secpercyl,
-                    ((pp->p_offset + pp->p_size) % lp->d_secpercyl) ? '*' : ' ',
-                    (long) pp->p_size / lp->d_secpercyl,
-                    (pp->p_size % lp->d_secpercyl) ? '*' : ' '
-                );
-            } else {
-                printf("  %c: %8ld  %8ld  %8ld   ",
-                    'a' + i,
-                    (long) pp->p_offset,
-                    (long) pp->p_offset + pp->p_size - 1,
-                    (long) pp->p_size
-                );
-            }
-
-            if ((unsigned) pp->p_fstype < BSD_FSMAXTYPES)
-                printf("%8.8s", xbsd_fstypes[pp->p_fstype].name);
-            else
-                printf("%8x", pp->p_fstype);
-
-            switch (pp->p_fstype) {
-            case BSD_FS_UNUSED:
-                printf("    %5ld %5ld %5.5s ",
-                    (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, "");
-                break;
-            case BSD_FS_BSDFFS:
-                printf("    %5ld %5ld %5d ",
-                    (long) pp->p_fsize, (long) pp->p_fsize * pp->p_frag, pp->p_cpg);
-                break;
-            default:
-                printf("%22.22s", "");
-                break;
-            }
-            printf("\n");
-        }
-    }
-}
-
-static void
-xbsd_write_disklabel(void)
-{
-#if defined (__alpha__)
-    printf(_("Writing disklabel to %s.\n"), disk_device);
-    xbsd_writelabel(NULL, &xbsd_dlabel);
-#else
-    printf(_("Writing disklabel to %s.\n"),
-        partname(disk_device, xbsd_part_index + 1, 0));
-    xbsd_writelabel(xbsd_part, &xbsd_dlabel);
-#endif
-    reread_partition_table(0);      /* no exit yet */
-}
-
-static int
-xbsd_create_disklabel(void)
-{
-    char c;
-
-#if defined (__alpha__)
-    fprintf(stderr, _("%s contains no disklabel.\n"), disk_device);
-#else
-    fprintf(stderr, _("%s contains no disklabel.\n"),
-        partname(disk_device, xbsd_part_index + 1, 0));
-#endif
-
-    while (1) {
-        c = read_char(_("Do you want to create a disklabel? (y/n) "));
-        if (c == 'y' || c == 'Y') {
-            if (xbsd_initlabel(
-#if defined (__alpha__) || defined (__powerpc__) || defined (__hppa__) || \
-    defined (__s390__) || defined (__s390x__)
-                NULL, &xbsd_dlabel
-#else
-                xbsd_part, &xbsd_dlabel/* not used, xbsd_part_index*/
-#endif
-                ) == 1) {
-                xbsd_print_disklabel (1);
-                return 1;
-            } else
-                return 0;
-        } else if (c == 'n')
-            return 0;
-    }
-}
-
-static int
-edit_int(int def, char *mesg)
-{
-    do {
-        fputs(mesg, stdout);
-        printf(" (%d): ", def);
-        if (!read_line())
-            return def;
-    }
-    while (!isdigit(*line_ptr));    /* FIXME: ?!! */
-    return atoi(line_ptr);
-}
-
-static void
-xbsd_edit_disklabel(void)
-{
-    struct xbsd_disklabel *d;
-
-    d = &xbsd_dlabel;
-
-#if defined (__alpha__) || defined (__ia64__)
-    d->d_secsize    = (u_long) edit_int((u_long) d->d_secsize     ,_("bytes/sector"));
-    d->d_nsectors   = (u_long) edit_int((u_long) d->d_nsectors    ,_("sectors/track"));
-    d->d_ntracks    = (u_long) edit_int((u_long) d->d_ntracks     ,_("tracks/cylinder"));
-    d->d_ncylinders = (u_long) edit_int((u_long) d->d_ncylinders  ,_("cylinders"));
-#endif
-
-  /* d->d_secpercyl can be != d->d_nsectors * d->d_ntracks */
-    while (1) {
-        d->d_secpercyl = (u_long) edit_int((u_long) d->d_nsectors * d->d_ntracks,
-                _("sectors/cylinder"));
-        if (d->d_secpercyl <= d->d_nsectors * d->d_ntracks)
-            break;
-
-        printf(_("Must be <= sectors/track * tracks/cylinder (default).\n"));
-    }
-    d->d_rpm        = (u_short) edit_int((u_short) d->d_rpm       ,_("rpm"));
-    d->d_interleave = (u_short) edit_int((u_short) d->d_interleave,_("interleave"));
-    d->d_trackskew  = (u_short) edit_int((u_short) d->d_trackskew ,_("trackskew"));
-    d->d_cylskew    = (u_short) edit_int((u_short) d->d_cylskew   ,_("cylinderskew"));
-    d->d_headswitch = (u_long) edit_int((u_long) d->d_headswitch  ,_("headswitch"));
-    d->d_trkseek    = (u_long) edit_int((u_long) d->d_trkseek     ,_("track-to-track seek"));
-
-    d->d_secperunit = d->d_secpercyl * d->d_ncylinders;
-}
-
-static int
-xbsd_get_bootstrap (char *path, void *ptr, int size)
-{
-    int fdb;
-
-    if ((fdb = open (path, O_RDONLY)) < 0) {
-        perror(path);
-        return 0;
-    }
-    if (read(fdb, ptr, size) < 0) {
-        perror(path);
-        close(fdb);
-        return 0;
-    }
-    printf(" ... %s\n", path);
-    close(fdb);
-    return 1;
-}
-
-static void
-sync_disks(void)
-{
-    printf(_("\nSyncing disks.\n"));
-    sync();
-    sleep(4); /* What? */
-}
-
-static void
-xbsd_write_bootstrap(void)
-{
-    char *bootdir = BSD_LINUX_BOOTDIR;
-    char path[MAXPATHLEN];
-    char *dkbasename;
-    struct xbsd_disklabel dl;
-    char *d, *p, *e;
-    int sector;
-
-    if (xbsd_dlabel.d_type == BSD_DTYPE_SCSI)
-        dkbasename = "sd";
-    else
-        dkbasename = "wd";
-
-    printf(_("Bootstrap: %sboot -> boot%s (%s): "),
-        dkbasename, dkbasename, dkbasename);
-    if (read_line()) {
-        line_ptr[strlen(line_ptr)-1] = '\0';
-        dkbasename = line_ptr;
-    }
-    snprintf(path, sizeof(path), "%s/%sboot", bootdir, dkbasename);
-    if (!xbsd_get_bootstrap(path, disklabelbuffer, (int) xbsd_dlabel.d_secsize))
-        return;
-
-/* We need a backup of the disklabel (xbsd_dlabel might have changed). */
-    d = &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE];
-    memmove(&dl, d, sizeof(struct xbsd_disklabel));
-
-/* The disklabel will be overwritten by 0's from bootxx anyway */
-    memset(d, 0, sizeof(struct xbsd_disklabel));
-
-    snprintf(path, sizeof(path), "%s/boot%s", bootdir, dkbasename);
-    if (!xbsd_get_bootstrap (path, &disklabelbuffer[xbsd_dlabel.d_secsize],
-              (int) xbsd_dlabel.d_bbsize - xbsd_dlabel.d_secsize))
-        return;
-
-    e = d + sizeof(struct xbsd_disklabel);
-    for (p = d; p < e; p++)
-        if (*p) {
-            fprintf(stderr, _("Bootstrap overlaps with disk label!\n"));
-            exit(EXIT_FAILURE);
-        }
-
-    memmove(d, &dl, sizeof(struct xbsd_disklabel));
-
-#if defined (__powerpc__) || defined (__hppa__)
-    sector = 0;
-#elif defined (__alpha__)
-    sector = 0;
-    alpha_bootblock_checksum(disklabelbuffer);
-#else
-    sector = get_start_sect(xbsd_part);
-#endif
-
-    if (lseek(fd, sector * SECTOR_SIZE, SEEK_SET) == -1)
-        fdisk_fatal(unable_to_seek);
-    if (BSD_BBSIZE != write(fd, disklabelbuffer, BSD_BBSIZE))
-        fdisk_fatal(unable_to_write);
-
-#if defined (__alpha__)
-    printf(_("Bootstrap installed on %s.\n"), disk_device);
-#else
-    printf(_("Bootstrap installed on %s.\n"),
-        partname (disk_device, xbsd_part_index+1, 0));
-#endif
-
-    sync_disks();
-}
-
-static void
-xbsd_change_fstype(void)
-{
-    int i;
-
-    i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
-    xbsd_dlabel.d_partitions[i].p_fstype = read_hex(xbsd_fstypes);
-}
-
-static int
-xbsd_get_part_index(int max)
-{
-    char prompt[256];
-    char l;
-
-    snprintf(prompt, sizeof(prompt), _("Partition (a-%c): "), 'a' + max - 1);
-    do
-            l = tolower(read_char(prompt));
-    while (l < 'a' || l > 'a' + max - 1);
-    return l - 'a';
-}
-
-static int
-xbsd_check_new_partition(int *i)
-{
-    /* room for more? various BSD flavours have different maxima */
-    if (xbsd_dlabel.d_npartitions == BSD_MAXPARTITIONS) {
-        int t;
-
-        for (t = 0; t < BSD_MAXPARTITIONS; t++)
-            if (xbsd_dlabel.d_partitions[t].p_size == 0)
-                break;
-
-        if (t == BSD_MAXPARTITIONS) {
-            fprintf(stderr, _("The maximum number of partitions "
-                       "has been created\n"));
-            return 0;
-        }
-    }
-
-    *i = xbsd_get_part_index (BSD_MAXPARTITIONS);
-
-    if (*i >= xbsd_dlabel.d_npartitions)
-        xbsd_dlabel.d_npartitions = (*i) + 1;
-
-    if (xbsd_dlabel.d_partitions[*i].p_size != 0) {
-        fprintf(stderr, _("This partition already exists.\n"));
-        return 0;
-    }
-
-    return 1;
-}
-
-static void
-xbsd_list_types(void)
-{
-    list_types(xbsd_fstypes);
-}
-
-static u_short
-xbsd_dkcksum(struct xbsd_disklabel *lp)
-{
-    u_short *start, *end;
-    u_short sum = 0;
-
-    start = (u_short *) lp;
-    end = (u_short *) &lp->d_partitions[lp->d_npartitions];
-    while (start < end)
-        sum ^= *start++;
-    return sum;
-}
-
-static int
-xbsd_initlabel(struct partition *p, struct xbsd_disklabel *d)
-{
-    struct xbsd_partition *pp;
-
-    get_geometry();
-    memset(d, 0, sizeof(struct xbsd_disklabel));
-
-    d->d_magic = BSD_DISKMAGIC;
-
-    if (strncmp(disk_device, "/dev/sd", 7) == 0)
-        d->d_type = BSD_DTYPE_SCSI;
-    else
-        d->d_type = BSD_DTYPE_ST506;
-
-#if 0 /* not used (at least not written to disk) by NetBSD/i386 1.0 */
-    d->d_subtype = BSD_DSTYPE_INDOSPART & pindex;
-#endif
-
-#if !defined (__alpha__)
-    d->d_flags = BSD_D_DOSPART;
-#else
-    d->d_flags = 0;
-#endif
-    d->d_secsize = SECTOR_SIZE;           /* bytes/sector  */
-    d->d_nsectors = sectors;            /* sectors/track */
-    d->d_ntracks = heads;               /* tracks/cylinder (heads) */
-    d->d_ncylinders = cylinders;
-    d->d_secpercyl  = sectors * heads;/* sectors/cylinder */
-    if (d->d_secpercyl == 0)
-        d->d_secpercyl = 1;           /* avoid segfaults */
-    d->d_secperunit = d->d_secpercyl * d->d_ncylinders;
-
-    d->d_rpm = 3600;
-    d->d_interleave = 1;
-    d->d_trackskew = 0;
-    d->d_cylskew = 0;
-    d->d_headswitch = 0;
-    d->d_trkseek = 0;
-
-    d->d_magic2 = BSD_DISKMAGIC;
-    d->d_bbsize = BSD_BBSIZE;
-    d->d_sbsize = BSD_SBSIZE;
-
-#if !defined (__alpha__)
-    d->d_npartitions = 4;
-    pp = &d->d_partitions[2];             /* Partition C should be
-                           the NetBSD partition */
-    pp->p_offset = get_start_sect(p);
-    pp->p_size   = get_nr_sects(p);
-    pp->p_fstype = BSD_FS_UNUSED;
-    pp = &d->d_partitions[3];             /* Partition D should be
-                           the whole disk */
-    pp->p_offset = 0;
-    pp->p_size   = d->d_secperunit;
-    pp->p_fstype = BSD_FS_UNUSED;
-#elif defined (__alpha__)
-    d->d_npartitions = 3;
-    pp = &d->d_partitions[2];             /* Partition C should be
-                           the whole disk */
-    pp->p_offset = 0;
-    pp->p_size   = d->d_secperunit;
-    pp->p_fstype = BSD_FS_UNUSED;
-#endif
-
-    return 1;
-}
-
-/*
- * Read a xbsd_disklabel from sector 0 or from the starting sector of p.
- * If it has the right magic, return 1.
- */
-static int
-xbsd_readlabel (struct partition *p, struct xbsd_disklabel *d)
-{
-    int t, sector;
-
-    /* p is used only to get the starting sector */
-#if !defined (__alpha__)
-    sector = (p ? get_start_sect(p) : 0);
-#elif defined (__alpha__)
-    sector = 0;
-#endif
-
-    if (lseek(fd, sector * SECTOR_SIZE, SEEK_SET) == -1)
-        fdisk_fatal(unable_to_seek);
-    if (BSD_BBSIZE != read(fd, disklabelbuffer, BSD_BBSIZE))
-        fdisk_fatal(unable_to_read);
-
-    memmove(d, &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET],
-           sizeof(struct xbsd_disklabel));
-
-    if (d->d_magic != BSD_DISKMAGIC || d->d_magic2 != BSD_DISKMAGIC)
-        return 0;
-
-    for (t = d->d_npartitions; t < BSD_MAXPARTITIONS; t++) {
-        d->d_partitions[t].p_size   = 0;
-        d->d_partitions[t].p_offset = 0;
-        d->d_partitions[t].p_fstype = BSD_FS_UNUSED;
-    }
-
-    if (d->d_npartitions > BSD_MAXPARTITIONS)
-        fprintf(stderr, _("Warning: too many partitions "
-                "(%d, maximum is %d).\n"),
-            d->d_npartitions, BSD_MAXPARTITIONS);
-    return 1;
-}
-
-static int
-xbsd_writelabel (struct partition *p, struct xbsd_disklabel *d)
-{
-    unsigned int sector;
-
-#if !defined (__alpha__) && !defined (__powerpc__) && !defined (__hppa__)
-    sector = get_start_sect(p) + BSD_LABELSECTOR;
-#else
-    sector = BSD_LABELSECTOR;
-#endif
-
-    d->d_checksum = 0;
-    d->d_checksum = xbsd_dkcksum (d);
-
-    /* This is necessary if we want to write the bootstrap later,
-       otherwise we'd write the old disklabel with the bootstrap.
-    */
-    memmove(&disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET],
-        d, sizeof(struct xbsd_disklabel));
-
-#if defined (__alpha__) && BSD_LABELSECTOR == 0
-    alpha_bootblock_checksum (disklabelbuffer);
-    if (lseek(fd, 0, SEEK_SET) == -1)
-        fdisk_fatal(unable_to_seek);
-    if (BSD_BBSIZE != write(fd, disklabelbuffer, BSD_BBSIZE))
-        fdisk_fatal(unable_to_write);
-#else
-    if (lseek(fd, sector * SECTOR_SIZE + BSD_LABELOFFSET, SEEK_SET) == -1)
-        fdisk_fatal(unable_to_seek);
-    if (sizeof(struct xbsd_disklabel) != write(fd, d, sizeof(struct xbsd_disklabel)))
-        fdisk_fatal(unable_to_write);
-#endif
-    sync_disks();
-    return 1;
-}
-
-
-#if !defined (__alpha__)
-static int
-xbsd_translate_fstype(int linux_type)
-{
-    switch (linux_type) {
-    case 0x01: /* DOS 12-bit FAT   */
-    case 0x04: /* DOS 16-bit <32M  */
-    case 0x06: /* DOS 16-bit >=32M */
-    case 0xe1: /* DOS access       */
-    case 0xe3: /* DOS R/O          */
-    case 0xf2: /* DOS secondary    */
-        return BSD_FS_MSDOS;
-    case 0x07: /* OS/2 HPFS        */
-        return BSD_FS_HPFS;
-    default:
-        return BSD_FS_OTHER;
-    }
-}
-
-static void
-xbsd_link_part(void)
-{
-    int k, i;
-    struct partition *p;
-
-    k = get_partition(1, partitions);
-
-    if (!xbsd_check_new_partition(&i))
-        return;
-
-    p = get_part_table(k);
-
-    xbsd_dlabel.d_partitions[i].p_size   = get_nr_sects(p);
-    xbsd_dlabel.d_partitions[i].p_offset = get_start_sect(p);
-    xbsd_dlabel.d_partitions[i].p_fstype = xbsd_translate_fstype(p->sys_ind);
-}
-#endif
-
-#if defined (__alpha__)
-
-#if !defined(__GLIBC__)
-typedef unsigned long long uint64_t;
-#endif
-
-static void
-alpha_bootblock_checksum(char *boot)
-{
-    uint64_t *dp, sum;
-    int i;
-
-    dp = (uint64_t *)boot;
-    sum = 0;
-    for (i = 0; i < 63; i++)
-        sum += dp[i];
-    dp[63] = sum;
-}
-#endif /* __alpha__ */
-
-#endif /* OSF_LABEL */
-
-#if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL)
-static inline unsigned short
-__swap16(unsigned short x)
-{
-    return (((uint16_t)(x) & 0xFF) << 8) | (((uint16_t)(x) & 0xFF00) >> 8);
-}
-
-static inline uint32_t
-__swap32(uint32_t x)
-{
-    return (((x & 0xFF) << 24) |
-        ((x & 0xFF00) << 8) |
-        ((x & 0xFF0000) >> 8) |
-        ((x & 0xFF000000) >> 24));
-}
-#endif
-
-#ifdef CONFIG_FEATURE_SGI_LABEL
-/*
- *
- * fdisksgilabel.c
- *
- * Copyright (C) Andreas Neuper, Sep 1998.
- *      This file may be modified and redistributed under
- *      the terms of the GNU Public License.
- *
- * Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
- *      Internationalization
- */
-
-
-static int sgi_other_endian;
-static int debug;
-static short sgi_volumes = 1;
-
-/*
- * only dealing with free blocks here
- */
-
-typedef struct {
-    unsigned int first;
-    unsigned int last;
-} freeblocks;
-static freeblocks freelist[17]; /* 16 partitions can produce 17 vacant slots */
-
-static void
-setfreelist(int i, unsigned int f, unsigned int l)
-{
-    freelist[i].first = f;
-    freelist[i].last = l;
-}
-
-static void
-add2freelist(unsigned int f, unsigned int l)
-{
-    int i;
-    for (i = 0; i < 17 ; i++)
-        if (freelist[i].last == 0)
-            break;
-    setfreelist(i, f, l);
-}
-
-static void
-clearfreelist(void)
-{
-    int i;
-
-    for (i = 0; i < 17 ; i++)
-        setfreelist(i, 0, 0);
-}
-
-static unsigned int
-isinfreelist(unsigned int b)
-{
-    int i;
-
-    for (i = 0; i < 17 ; i++)
-        if (freelist[i].first <= b && freelist[i].last >= b)
-            return freelist[i].last;
-    return 0;
-}
-    /* return last vacant block of this stride (never 0). */
-    /* the '>=' is not quite correct, but simplifies the code */
-/*
- * end of free blocks section
- */
-
-static const struct systypes sgi_sys_types[] = {
-/* SGI_VOLHDR   */  { "\x00" "SGI volhdr"   },
-/* 0x01         */  { "\x01" "SGI trkrepl"  },
-/* 0x02         */  { "\x02" "SGI secrepl"  },
-/* SGI_SWAP     */  { "\x03" "SGI raw"      },
-/* 0x04         */  { "\x04" "SGI bsd"      },
-/* 0x05         */  { "\x05" "SGI sysv"     },
-/* ENTIRE_DISK  */  { "\x06" "SGI volume"   },
-/* SGI_EFS      */  { "\x07" "SGI efs"      },
-/* 0x08         */  { "\x08" "SGI lvol"     },
-/* 0x09         */  { "\x09" "SGI rlvol"    },
-/* SGI_XFS      */  { "\x0a" "SGI xfs"      },
-/* SGI_XFSLOG   */  { "\x0b" "SGI xfslog"   },
-/* SGI_XLV      */  { "\x0c" "SGI xlv"      },
-/* SGI_XVM      */  { "\x0d" "SGI xvm"      },
-/* LINUX_SWAP   */  { "\x82" "Linux swap"   },
-/* LINUX_NATIVE */  { "\x83" "Linux native" },
-/* LINUX_LVM    */  { "\x8d" "Linux LVM"    },
-/* LINUX_RAID   */  { "\xfd" "Linux RAID"   },
-            { NULL             }
-};
-
-
-static int
-sgi_get_nsect(void)
-{
-    return SGI_SSWAP16(sgilabel->devparam.nsect);
-}
-
-static int
-sgi_get_ntrks(void)
-{
-    return SGI_SSWAP16(sgilabel->devparam.ntrks);
-}
-
-static unsigned int
-two_s_complement_32bit_sum(unsigned int* base, int size /* in bytes */)
-{
-    int i = 0;
-    unsigned int sum = 0;
-
-    size /= sizeof(unsigned int);
-    for (i = 0; i < size; i++)
-        sum -= SGI_SSWAP32(base[i]);
-    return sum;
-}
-
-static int
-check_sgi_label(void)
-{
-    if (sizeof(sgilabel) > 512) {
-        fprintf(stderr,
-            _("According to MIPS Computer Systems, Inc the "
-            "Label must not contain more than 512 bytes\n"));
-        exit(1);
-    }
-
-    if (sgilabel->magic != SGI_LABEL_MAGIC
-     && sgilabel->magic != SGI_LABEL_MAGIC_SWAPPED) {
-        current_label_type = label_dos;
-        return 0;
-    }
-
-    sgi_other_endian = (sgilabel->magic == SGI_LABEL_MAGIC_SWAPPED);
-    /*
-     * test for correct checksum
-     */
-    if (two_s_complement_32bit_sum((unsigned int*)sgilabel,
-                sizeof(*sgilabel))) {
-        fprintf(stderr,
-            _("Detected sgi disklabel with wrong checksum.\n"));
-    }
-    update_units();
-    current_label_type = label_sgi;
-    partitions = 16;
-    sgi_volumes = 15;
-    return 1;
-}
-
-static unsigned int
-sgi_get_start_sector(int i)
-{
-    return SGI_SSWAP32(sgilabel->partitions[i].start_sector);
-}
-
-static unsigned int
-sgi_get_num_sectors(int i)
-{
-    return SGI_SSWAP32(sgilabel->partitions[i].num_sectors);
-}
-
-static int
-sgi_get_sysid(int i)
-{
-    return SGI_SSWAP32(sgilabel->partitions[i].id);
-}
-
-static int
-sgi_get_bootpartition(void)
-{
-    return SGI_SSWAP16(sgilabel->boot_part);
-}
-
-static int
-sgi_get_swappartition(void)
-{
-    return SGI_SSWAP16(sgilabel->swap_part);
-}
-
-static void
-sgi_list_table(int xtra)
-{
-    int i, w, wd;
-    int kpi = 0;                /* kernel partition ID */
-
-    if(xtra) {
-        printf(_("\nDisk %s (SGI disk label): %d heads, %d sectors\n"
-            "%d cylinders, %d physical cylinders\n"
-            "%d extra sects/cyl, interleave %d:1\n"
-            "%s\n"
-            "Units = %s of %d * 512 bytes\n\n"),
-            disk_device, heads, sectors, cylinders,
-            SGI_SSWAP16(sgiparam.pcylcount),
-            SGI_SSWAP16(sgiparam.sparecyl),
-            SGI_SSWAP16(sgiparam.ilfact),
-            (char *)sgilabel,
-            str_units(PLURAL), units_per_sector);
-    } else {
-        printf( _("\nDisk %s (SGI disk label): "
-            "%d heads, %d sectors, %d cylinders\n"
-            "Units = %s of %d * 512 bytes\n\n"),
-            disk_device, heads, sectors, cylinders,
-            str_units(PLURAL), units_per_sector );
-    }
-
-    w = strlen(disk_device);
-    wd = strlen(_("Device"));
-    if (w < wd)
-    w = wd;
-
-    printf(_("----- partitions -----\n"
-        "Pt# %*s  Info     Start       End   Sectors  Id  System\n"),
-        w + 2, _("Device"));
-    for (i = 0 ; i < partitions; i++) {
-        if( sgi_get_num_sectors(i) || debug ) {
-            uint32_t start = sgi_get_start_sector(i);
-            uint32_t len = sgi_get_num_sectors(i);
-            kpi++;              /* only count nonempty partitions */
-            printf(
-            "%2d: %s %4s %9ld %9ld %9ld  %2x  %s\n",
-/* fdisk part number */ i+1,
-/* device */            partname(disk_device, kpi, w+3),
-/* flags */             (sgi_get_swappartition() == i) ? "swap" :
-/* flags */             (sgi_get_bootpartition() == i) ? "boot" : "    ",
-/* start */             (long) scround(start),
-/* end */               (long) scround(start+len)-1,
-/* no odd flag on end */(long) len,
-/* type id */           sgi_get_sysid(i),
-/* type name */         partition_type(sgi_get_sysid(i)));
-        }
-    }
-    printf(_("----- Bootinfo -----\nBootfile: %s\n"
-        "----- Directory Entries -----\n"),
-        sgilabel->boot_file);
-    for (i = 0 ; i < sgi_volumes; i++) {
-        if (sgilabel->directory[i].vol_file_size) {
-            uint32_t start = SGI_SSWAP32(sgilabel->directory[i].vol_file_start);
-            uint32_t len = SGI_SSWAP32(sgilabel->directory[i].vol_file_size);
-            unsigned char *name = sgilabel->directory[i].vol_file_name;
-
-            printf(_("%2d: %-10s sector%5u size%8u\n"),
-                i, (char*)name, (unsigned int) start, (unsigned int) len);
-        }
-    }
-}
-
-static void
-sgi_set_bootpartition(int i)
-{
-    sgilabel->boot_part = SGI_SSWAP16(((short)i));
-}
-
-static unsigned int
-sgi_get_lastblock(void)
-{
-    return heads * sectors * cylinders;
-}
-
-static void
-sgi_set_swappartition(int i)
-{
-    sgilabel->swap_part = SGI_SSWAP16(((short)i));
-}
-
-static int
-sgi_check_bootfile(const char* aFile)
-{
-    if (strlen(aFile) < 3) /* "/a\n" is minimum */ {
-        printf(_("\nInvalid Bootfile!\n"
-            "\tThe bootfile must be an absolute non-zero pathname,\n"
-            "\te.g. \"/unix\" or \"/unix.save\".\n"));
-        return 0;
-    } else {
-        if (strlen(aFile) > 16) {
-            printf(_("\n\tName of Bootfile too long:  "
-                "16 bytes maximum.\n"));
-            return 0;
-        } else {
-            if (aFile[0] != '/') {
-                printf(_("\n\tBootfile must have a "
-                    "fully qualified pathname.\n"));
-                return 0;
-            }
-        }
-    }
-    if (strncmp(aFile, (char*)sgilabel->boot_file, 16)) {
-        printf(_("\n\tBe aware, that the bootfile is not checked for existence.\n\t"
-             "SGI's default is \"/unix\" and for backup \"/unix.save\".\n"));
-        /* filename is correct and did change */
-        return 1;
-    }
-    return 0;   /* filename did not change */
-}
-
-static const char *
-sgi_get_bootfile(void)
-{
-    return (char*)sgilabel->boot_file;
-}
-
-static void
-sgi_set_bootfile(const char* aFile)
-{
-    int i = 0;
-
-    if (sgi_check_bootfile(aFile)) {
-        while (i < 16) {
-            if ((aFile[i] != '\n')  /* in principle caught again by next line */
-             && (strlen(aFile) > i))
-                sgilabel->boot_file[i] = aFile[i];
-            else
-                sgilabel->boot_file[i] = 0;
-            i++;
-        }
-        printf(_("\n\tBootfile is changed to \"%s\".\n"), sgilabel->boot_file);
-    }
-}
-
-static void
-create_sgiinfo(void)
-{
-    /* I keep SGI's habit to write the sgilabel to the second block */
-    sgilabel->directory[0].vol_file_start = SGI_SSWAP32(2);
-    sgilabel->directory[0].vol_file_size = SGI_SSWAP32(sizeof(sgiinfo));
-    strcpy((char*)sgilabel->directory[0].vol_file_name, "sgilabel");
-}
-
-static sgiinfo *fill_sgiinfo(void);
-
-static void
-sgi_write_table(void)
-{
-    sgilabel->csum = 0;
-    sgilabel->csum = SGI_SSWAP32(two_s_complement_32bit_sum(
-            (unsigned int*)sgilabel, sizeof(*sgilabel)));
-    assert(two_s_complement_32bit_sum(
-        (unsigned int*)sgilabel, sizeof(*sgilabel)) == 0);
-
-    if (lseek(fd, 0, SEEK_SET) < 0)
-        fdisk_fatal(unable_to_seek);
-    if (write(fd, sgilabel, SECTOR_SIZE) != SECTOR_SIZE)
-        fdisk_fatal(unable_to_write);
-    if (!strncmp((char*)sgilabel->directory[0].vol_file_name, "sgilabel", 8)) {
-        /*
-         * keep this habit of first writing the "sgilabel".
-         * I never tested whether it works without (AN 981002).
-         */
-        sgiinfo *info = fill_sgiinfo();
-        int infostartblock = SGI_SSWAP32(sgilabel->directory[0].vol_file_start);
-        if (lseek(fd, infostartblock*SECTOR_SIZE, SEEK_SET) < 0)
-            fdisk_fatal(unable_to_seek);
-        if (write(fd, info, SECTOR_SIZE) != SECTOR_SIZE)
-            fdisk_fatal(unable_to_write);
-        free(info);
-    }
-}
-
-static int
-compare_start(int *x, int *y)
-{
-    /*
-     * sort according to start sectors
-     * and prefers largest partition:
-     * entry zero is entire disk entry
-     */
-    unsigned int i = *x;
-    unsigned int j = *y;
-    unsigned int a = sgi_get_start_sector(i);
-    unsigned int b = sgi_get_start_sector(j);
-    unsigned int c = sgi_get_num_sectors(i);
-    unsigned int d = sgi_get_num_sectors(j);
-
-    if (a == b)
-        return (d > c) ? 1 : (d == c) ? 0 : -1;
-    return (a > b) ? 1 : -1;
-}
-
-
-static int
-verify_sgi(int verbose)
-{
-    int Index[16];      /* list of valid partitions */
-    int sortcount = 0;  /* number of used partitions, i.e. non-zero lengths */
-    int entire = 0, i = 0;
-    unsigned int start = 0;
-    long long gap = 0;      /* count unused blocks */
-    unsigned int lastblock = sgi_get_lastblock();
-
-    clearfreelist();
-    for (i = 0; i < 16; i++) {
-        if (sgi_get_num_sectors(i) != 0) {
-            Index[sortcount++] = i;
-            if (sgi_get_sysid(i) == ENTIRE_DISK) {
-                if (entire++ == 1) {
-                    if (verbose)
-                        printf(_("More than one entire disk entry present.\n"));
-                }
-            }
-        }
-    }
-    if (sortcount == 0) {
-        if (verbose)
-            printf(_("No partitions defined\n"));
-        return (lastblock > 0) ? 1 : (lastblock == 0) ? 0 : -1;
-    }
-    qsort(Index, sortcount, sizeof(Index[0]), (void*)compare_start);
-    if (sgi_get_sysid(Index[0]) == ENTIRE_DISK) {
-        if ((Index[0] != 10) && verbose)
-            printf(_("IRIX likes when Partition 11 covers the entire disk.\n"));
-        if ((sgi_get_start_sector(Index[0]) != 0) && verbose)
-            printf(_("The entire disk partition should start "
-                "at block 0,\n"
-                "not at diskblock %d.\n"),
-        sgi_get_start_sector(Index[0]));
-        if (debug)      /* I do not understand how some disks fulfil it */
-            if ((sgi_get_num_sectors(Index[0]) != lastblock) && verbose)
-                printf(_("The entire disk partition is only %d diskblock large,\n"
-                    "but the disk is %d diskblocks long.\n"),
-        sgi_get_num_sectors(Index[0]), lastblock);
-        lastblock = sgi_get_num_sectors(Index[0]);
-    } else {
-        if (verbose)
-            printf(_("One Partition (#11) should cover the entire disk.\n"));
-        if (debug > 2)
-            printf("sysid=%d\tpartition=%d\n",
-                sgi_get_sysid(Index[0]), Index[0]+1);
-    }
-    for (i = 1, start = 0; i < sortcount; i++) {
-        int cylsize = sgi_get_nsect() * sgi_get_ntrks();
-
-        if ((sgi_get_start_sector(Index[i]) % cylsize) != 0) {
-            if (debug)      /* I do not understand how some disks fulfil it */
-                if (verbose)
-                    printf(_("Partition %d does not start on cylinder boundary.\n"),
-                        Index[i]+1);
-        }
-        if (sgi_get_num_sectors(Index[i]) % cylsize != 0) {
-            if (debug)      /* I do not understand how some disks fulfil it */
-                if (verbose)
-                    printf(_("Partition %d does not end on cylinder boundary.\n"),
-                        Index[i]+1);
-        }
-        /* We cannot handle several "entire disk" entries. */
-        if (sgi_get_sysid(Index[i]) == ENTIRE_DISK) continue;
-        if (start > sgi_get_start_sector(Index[i])) {
-            if (verbose)
-                printf(_("The Partition %d and %d overlap by %d sectors.\n"),
-                    Index[i-1]+1, Index[i]+1,
-                    start - sgi_get_start_sector(Index[i]));
-            if (gap >  0) gap = -gap;
-            if (gap == 0) gap = -1;
-        }
-        if (start < sgi_get_start_sector(Index[i])) {
-            if (verbose)
-                printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"),
-                    sgi_get_start_sector(Index[i]) - start,
-                    start, sgi_get_start_sector(Index[i])-1);
-            gap += sgi_get_start_sector(Index[i]) - start;
-            add2freelist(start, sgi_get_start_sector(Index[i]));
-        }
-        start = sgi_get_start_sector(Index[i])
-               + sgi_get_num_sectors(Index[i]);
-        if (debug > 1) {
-            if (verbose)
-                printf("%2d:%12d\t%12d\t%12d\n", Index[i],
-                    sgi_get_start_sector(Index[i]),
-                    sgi_get_num_sectors(Index[i]),
-                    sgi_get_sysid(Index[i]));
-        }
-    }
-    if (start < lastblock) {
-        if (verbose)
-            printf(_("Unused gap of %8u sectors - sectors %8u-%u\n"),
-                lastblock - start, start, lastblock-1);
-        gap += lastblock - start;
-        add2freelist(start, lastblock);
-    }
-    /*
-     * Done with arithmetics
-     * Go for details now
-     */
-    if (verbose) {
-        if (!sgi_get_num_sectors(sgi_get_bootpartition())) {
-            printf(_("\nThe boot partition does not exist.\n"));
-        }
-        if (!sgi_get_num_sectors(sgi_get_swappartition())) {
-            printf(_("\nThe swap partition does not exist.\n"));
-        } else {
-            if ((sgi_get_sysid(sgi_get_swappartition()) != SGI_SWAP)
-             && (sgi_get_sysid(sgi_get_swappartition()) != LINUX_SWAP))
-                printf(_("\nThe swap partition has no swap type.\n"));
-        }
-        if (sgi_check_bootfile("/unix"))
-            printf(_("\tYou have chosen an unusual boot file name.\n"));
-    }
-    return (gap > 0) ? 1 : (gap == 0) ? 0 : -1;
-}
-
-static int
-sgi_gaps(void)
-{
-    /*
-     * returned value is:
-     *  = 0 : disk is properly filled to the rim
-     *  < 0 : there is an overlap
-     *  > 0 : there is still some vacant space
-     */
-    return verify_sgi(0);
-}
-
-static void
-sgi_change_sysid(int i, int sys)
-{
-    if( sgi_get_num_sectors(i) == 0 ) { /* caught already before, ... */
-        printf(_("Sorry You may change the Tag of non-empty partitions.\n"));
-        return;
-    }
-    if (((sys != ENTIRE_DISK ) && (sys != SGI_VOLHDR))
-     && (sgi_get_start_sector(i) < 1) ) {
-        read_chars(
-            _("It is highly recommended that the partition at offset 0\n"
-            "is of type \"SGI volhdr\", the IRIX system will rely on it to\n"
-            "retrieve from its directory standalone tools like sash and fx.\n"
-            "Only the \"SGI volume\" entire disk section may violate this.\n"
-            "Type YES if you are sure about tagging this partition differently.\n"));
-        if (strcmp(line_ptr, _("YES\n")))
-            return;
-    }
-    sgilabel->partitions[i].id = SGI_SSWAP32(sys);
-}
-
-/* returns partition index of first entry marked as entire disk */
-static int
-sgi_entire(void)
-{
-    int i;
-
-    for (i = 0; i < 16; i++)
-        if (sgi_get_sysid(i) == SGI_VOLUME)
-            return i;
-    return -1;
-}
-
-static void
-sgi_set_partition(int i, unsigned int start, unsigned int length, int sys)
-{
-    sgilabel->partitions[i].id = SGI_SSWAP32(sys);
-    sgilabel->partitions[i].num_sectors = SGI_SSWAP32(length);
-    sgilabel->partitions[i].start_sector = SGI_SSWAP32(start);
-    set_changed(i);
-    if (sgi_gaps() < 0)     /* rebuild freelist */
-        printf(_("Do You know, You got a partition overlap on the disk?\n"));
-}
-
-static void
-sgi_set_entire(void)
-{
-    int n;
-
-    for (n = 10; n < partitions; n++) {
-        if(!sgi_get_num_sectors(n) ) {
-            sgi_set_partition(n, 0, sgi_get_lastblock(), SGI_VOLUME);
-            break;
-        }
-    }
-}
-
-static void
-sgi_set_volhdr(void)
-{
-    int n;
-
-    for (n = 8; n < partitions; n++) {
-    if (!sgi_get_num_sectors(n)) {
-        /*
-         * 5 cylinders is an arbitrary value I like
-         * IRIX 5.3 stored files in the volume header
-         * (like sash, symmon, fx, ide) with ca. 3200
-         * sectors.
-         */
-        if (heads * sectors * 5 < sgi_get_lastblock())
-            sgi_set_partition(n, 0, heads * sectors * 5, SGI_VOLHDR);
-            break;
-        }
-    }
-}
-
-static void
-sgi_delete_partition(int i)
-{
-    sgi_set_partition(i, 0, 0, 0);
-}
-
-static void
-sgi_add_partition(int n, int sys)
-{
-    char mesg[256];
-    unsigned int first = 0, last = 0;
-
-    if (n == 10) {
-        sys = SGI_VOLUME;
-    } else if (n == 8) {
-        sys = 0;
-    }
-    if(sgi_get_num_sectors(n)) {
-        printf(_("Partition %d is already defined.  Delete "
-            "it before re-adding it.\n"), n + 1);
-        return;
-    }
-    if ((sgi_entire() == -1) && (sys != SGI_VOLUME)) {
-        printf(_("Attempting to generate entire disk entry automatically.\n"));
-        sgi_set_entire();
-        sgi_set_volhdr();
-    }
-    if ((sgi_gaps() == 0) && (sys != SGI_VOLUME)) {
-        printf(_("The entire disk is already covered with partitions.\n"));
-        return;
-    }
-    if (sgi_gaps() < 0) {
-        printf(_("You got a partition overlap on the disk. Fix it first!\n"));
-        return;
-    }
-    snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
-    while (1) {
-        if(sys == SGI_VOLUME) {
-            last = sgi_get_lastblock();
-            first = read_int(0, 0, last-1, 0, mesg);
-            if (first != 0) {
-                printf(_("It is highly recommended that eleventh partition\n"
-                        "covers the entire disk and is of type `SGI volume'\n"));
-            }
-        } else {
-            first = freelist[0].first;
-            last  = freelist[0].last;
-            first = read_int(scround(first), scround(first), scround(last)-1,
-                0, mesg);
-        }
-        if (display_in_cyl_units)
-            first *= units_per_sector;
-        else
-            first = first; /* align to cylinder if you know how ... */
-        if(!last )
-            last = isinfreelist(first);
-        if(last == 0) {
-            printf(_("You will get a partition overlap on the disk. "
-                "Fix it first!\n"));
-        } else
-            break;
-    }
-    snprintf(mesg, sizeof(mesg), _(" Last %s"), str_units(SINGULAR));
-    last = read_int(scround(first), scround(last)-1, scround(last)-1,
-            scround(first), mesg)+1;
-    if (display_in_cyl_units)
-        last *= units_per_sector;
-    else
-        last = last; /* align to cylinder if You know how ... */
-    if ( (sys == SGI_VOLUME) && (first != 0 || last != sgi_get_lastblock() ) )
-        printf(_("It is highly recommended that eleventh partition\n"
-            "covers the entire disk and is of type `SGI volume'\n"));
-    sgi_set_partition(n, first, last-first, sys);
-}
-
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
-static void
-create_sgilabel(void)
-{
-    struct hd_geometry geometry;
-    struct {
-        unsigned int start;
-        unsigned int nsect;
-        int sysid;
-    } old[4];
-    int i = 0;
-    long longsectors;               /* the number of sectors on the device */
-    int res;                        /* the result from the ioctl */
-    int sec_fac;                    /* the sector factor */
-
-    sec_fac = sector_size / 512;    /* determine the sector factor */
-
-    fprintf( stderr,
-        _("Building a new SGI disklabel. Changes will remain in memory only,\n"
-        "until you decide to write them. After that, of course, the previous\n"
-        "content will be unrecoverably lost.\n\n"));
-
-    sgi_other_endian = (BB_LITTLE_ENDIAN);
-    res = ioctl(fd, BLKGETSIZE, &longsectors);
-    if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
-        heads = geometry.heads;
-        sectors = geometry.sectors;
-        if (res == 0) {
-            /* the get device size ioctl was successful */
-            cylinders = longsectors / (heads * sectors);
-            cylinders /= sec_fac;
-        } else {
-            /* otherwise print error and use truncated version */
-            cylinders = geometry.cylinders;
-            fprintf(stderr,
-                _("Warning:  BLKGETSIZE ioctl failed on %s.  "
-                "Using geometry cylinder value of %d.\n"
-                "This value may be truncated for devices"
-                " > 33.8 GB.\n"), disk_device, cylinders);
-        }
-    }
-    for (i = 0; i < 4; i++) {
-        old[i].sysid = 0;
-        if (valid_part_table_flag(MBRbuffer)) {
-            if(get_part_table(i)->sys_ind) {
-                old[i].sysid = get_part_table(i)->sys_ind;
-                old[i].start = get_start_sect(get_part_table(i));
-                old[i].nsect = get_nr_sects(get_part_table(i));
-                printf(_("Trying to keep parameters of partition %d.\n"), i);
-                if (debug)
-                    printf(_("ID=%02x\tSTART=%d\tLENGTH=%d\n"),
-                old[i].sysid, old[i].start, old[i].nsect);
-            }
-        }
-    }
-
-    memset(MBRbuffer, 0, sizeof(MBRbuffer));
-    sgilabel->magic = SGI_SSWAP32(SGI_LABEL_MAGIC);
-    sgilabel->boot_part = SGI_SSWAP16(0);
-    sgilabel->swap_part = SGI_SSWAP16(1);
-
-    /* sizeof(sgilabel->boot_file) = 16 > 6 */
-    memset(sgilabel->boot_file, 0, 16);
-    strcpy((char*)sgilabel->boot_file, "/unix");
-
-    sgilabel->devparam.skew                     = (0);
-    sgilabel->devparam.gap1                     = (0);
-    sgilabel->devparam.gap2                     = (0);
-    sgilabel->devparam.sparecyl                 = (0);
-    sgilabel->devparam.pcylcount                = SGI_SSWAP16(geometry.cylinders);
-    sgilabel->devparam.head_vol0                = SGI_SSWAP16(0);
-    sgilabel->devparam.ntrks                    = SGI_SSWAP16(geometry.heads);
-                        /* tracks/cylinder (heads) */
-    sgilabel->devparam.cmd_tag_queue_depth      = (0);
-    sgilabel->devparam.unused0                  = (0);
-    sgilabel->devparam.unused1                  = SGI_SSWAP16(0);
-    sgilabel->devparam.nsect                    = SGI_SSWAP16(geometry.sectors);
-                        /* sectors/track */
-    sgilabel->devparam.bytes                    = SGI_SSWAP16(512);
-    sgilabel->devparam.ilfact                   = SGI_SSWAP16(1);
-    sgilabel->devparam.flags                    = SGI_SSWAP32(TRACK_FWD|
-                            IGNORE_ERRORS|RESEEK);
-    sgilabel->devparam.datarate                 = SGI_SSWAP32(0);
-    sgilabel->devparam.retries_on_error         = SGI_SSWAP32(1);
-    sgilabel->devparam.ms_per_word              = SGI_SSWAP32(0);
-    sgilabel->devparam.xylogics_gap1            = SGI_SSWAP16(0);
-    sgilabel->devparam.xylogics_syncdelay       = SGI_SSWAP16(0);
-    sgilabel->devparam.xylogics_readdelay       = SGI_SSWAP16(0);
-    sgilabel->devparam.xylogics_gap2            = SGI_SSWAP16(0);
-    sgilabel->devparam.xylogics_readgate        = SGI_SSWAP16(0);
-    sgilabel->devparam.xylogics_writecont       = SGI_SSWAP16(0);
-    memset( &(sgilabel->directory), 0, sizeof(struct volume_directory)*15 );
-    memset( &(sgilabel->partitions), 0, sizeof(struct sgi_partition)*16 );
-    current_label_type = label_sgi;
-    partitions = 16;
-    sgi_volumes = 15;
-    sgi_set_entire();
-    sgi_set_volhdr();
-    for (i = 0; i < 4; i++) {
-        if(old[i].sysid) {
-            sgi_set_partition(i, old[i].start, old[i].nsect, old[i].sysid);
-        }
-    }
-}
-
-static void
-sgi_set_xcyl(void)
-{
-    /* do nothing in the beginning */
-}
-#endif /* CONFIG_FEATURE_FDISK_ADVANCED */
-
-/* _____________________________________________________________
- */
-
-static sgiinfo *
-fill_sgiinfo(void)
-{
-    sgiinfo *info = calloc(1, sizeof(sgiinfo));
-
-    info->magic = SGI_SSWAP32(SGI_INFO_MAGIC);
-    info->b1 = SGI_SSWAP32(-1);
-    info->b2 = SGI_SSWAP16(-1);
-    info->b3 = SGI_SSWAP16(1);
-    /* You may want to replace this string !!!!!!! */
-    strcpy( (char*)info->scsi_string, "IBM OEM 0662S12         3 30" );
-    strcpy( (char*)info->serial, "0000" );
-    info->check1816 = SGI_SSWAP16(18*256 +16 );
-    strcpy( (char*)info->installer, "Sfx version 5.3, Oct 18, 1994" );
-    return info;
-}
-#endif /* SGI_LABEL */
-
-
-#ifdef CONFIG_FEATURE_SUN_LABEL
-/*
- * fdisksunlabel.c
- *
- * I think this is mostly, or entirely, due to
- *      Jakub Jelinek (jj@sunsite.mff.cuni.cz), July 1996
- *
- * Merged with fdisk for other architectures, aeb, June 1998.
- *
- * Sat Mar 20 EST 1999 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
- *      Internationalization
- */
-
-
-static int sun_other_endian;
-static int scsi_disk;
-static int floppy;
-
-#ifndef IDE0_MAJOR
-#define IDE0_MAJOR 3
-#endif
-#ifndef IDE1_MAJOR
-#define IDE1_MAJOR 22
-#endif
-
-static void
-guess_device_type(void)
-{
-    struct stat bootstat;
-
-    if (fstat(fd, &bootstat) < 0) {
-        scsi_disk = 0;
-        floppy = 0;
-    } else if (S_ISBLK(bootstat.st_mode)
-        && (major(bootstat.st_rdev) == IDE0_MAJOR ||
-            major(bootstat.st_rdev) == IDE1_MAJOR)) {
-        scsi_disk = 0;
-        floppy = 0;
-    } else if (S_ISBLK(bootstat.st_mode)
-        && major(bootstat.st_rdev) == FLOPPY_MAJOR) {
-        scsi_disk = 0;
-        floppy = 1;
-    } else {
-        scsi_disk = 1;
-        floppy = 0;
-    }
-}
-
-static const struct systypes sun_sys_types[] = {
-    { "\x00" "Empty"        }, /* 0            */
-    { "\x01" "Boot"         }, /* 1            */
-    { "\x02" "SunOS root"   }, /* 2            */
-    { "\x03" "SunOS swap"   }, /* SUNOS_SWAP   */
-    { "\x04" "SunOS usr"    }, /* 4            */
-    { "\x05" "Whole disk"   }, /* WHOLE_DISK   */
-    { "\x06" "SunOS stand"  }, /* 6            */
-    { "\x07" "SunOS var"    }, /* 7            */
-    { "\x08" "SunOS home"   }, /* 8            */
-    { "\x82" "Linux swap"   }, /* LINUX_SWAP   */
-    { "\x83" "Linux native" }, /* LINUX_NATIVE */
-    { "\x8e" "Linux LVM"    }, /* 0x8e         */
-/* New (2.2.x) raid partition with autodetect using persistent superblock */
-    { "\xfd" "Linux raid autodetect" }, /* 0xfd         */  
-    { NULL }
-};
-
-
-static void
-set_sun_partition(int i, uint start, uint stop, int sysid)
-{
-    sunlabel->infos[i].id = sysid;
-    sunlabel->partitions[i].start_cylinder =
-        SUN_SSWAP32(start / (heads * sectors));
-    sunlabel->partitions[i].num_sectors =
-        SUN_SSWAP32(stop - start);
-    set_changed(i);
-}
-
-static int
-check_sun_label(void)
-{
-    unsigned short *ush;
-    int csum;
-
-    if (sunlabel->magic != SUN_LABEL_MAGIC
-     && sunlabel->magic != SUN_LABEL_MAGIC_SWAPPED) {
-        current_label_type = label_dos;
-        sun_other_endian = 0;
-        return 0;
-    }
-    sun_other_endian = (sunlabel->magic == SUN_LABEL_MAGIC_SWAPPED);
-    ush = ((unsigned short *) (sunlabel + 1)) - 1;
-    for (csum = 0; ush >= (unsigned short *)sunlabel;) csum ^= *ush--;
-    if (csum) {
-        fprintf(stderr,_("Detected sun disklabel with wrong checksum.\n"
-                "Probably you'll have to set all the values,\n"
-                "e.g. heads, sectors, cylinders and partitions\n"
-                "or force a fresh label (s command in main menu)\n"));
-    } else {
-        heads = SUN_SSWAP16(sunlabel->ntrks);
-        cylinders = SUN_SSWAP16(sunlabel->ncyl);
-        sectors = SUN_SSWAP16(sunlabel->nsect);
-    }
-    update_units();
-    current_label_type = label_sun;
-    partitions = 8;
-    return 1;
-}
-
-static const struct sun_predefined_drives {
-    const char *vendor;
-    const char *model;
-    unsigned short sparecyl;
-    unsigned short ncyl;
-    unsigned short nacyl;
-    unsigned short pcylcount;
-    unsigned short ntrks;
-    unsigned short nsect;
-    unsigned short rspeed;
-} sun_drives[] = {
-    { "Quantum","ProDrive 80S",1,832,2,834,6,34,3662},
-    { "Quantum","ProDrive 105S",1,974,2,1019,6,35,3662},
-    { "CDC","Wren IV 94171-344",3,1545,2,1549,9,46,3600},
-    { "IBM","DPES-31080",0,4901,2,4903,4,108,5400},
-    { "IBM","DORS-32160",0,1015,2,1017,67,62,5400},
-    { "IBM","DNES-318350",0,11199,2,11474,10,320,7200},
-    { "SEAGATE","ST34371",0,3880,2,3882,16,135,7228},
-    { "","SUN0104",1,974,2,1019,6,35,3662},
-    { "","SUN0207",4,1254,2,1272,9,36,3600},
-    { "","SUN0327",3,1545,2,1549,9,46,3600},
-    { "","SUN0340",0,1538,2,1544,6,72,4200},
-    { "","SUN0424",2,1151,2,2500,9,80,4400},
-    { "","SUN0535",0,1866,2,2500,7,80,5400},
-    { "","SUN0669",5,1614,2,1632,15,54,3600},
-    { "","SUN1.0G",5,1703,2,1931,15,80,3597},
-    { "","SUN1.05",0,2036,2,2038,14,72,5400},
-    { "","SUN1.3G",6,1965,2,3500,17,80,5400},
-    { "","SUN2.1G",0,2733,2,3500,19,80,5400},
-    { "IOMEGA","Jaz",0,1019,2,1021,64,32,5394},
-};
-
-static const struct sun_predefined_drives *
-sun_autoconfigure_scsi(void)
-{
-    const struct sun_predefined_drives *p = NULL;
-
-#ifdef SCSI_IOCTL_GET_IDLUN
-    unsigned int id[2];
-    char buffer[2048];
-    char buffer2[2048];
-    FILE *pfd;
-    char *vendor;
-    char *model;
-    char *q;
-    int i;
-
-    if (!ioctl(fd, SCSI_IOCTL_GET_IDLUN, &id)) {
-        sprintf(buffer,
-            "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n",
-#if 0
-            ((id[0]>>24)&0xff)-/*PROC_SCSI_SCSI+PROC_SCSI_FILE*/33,
-#else
-            /* This is very wrong (works only if you have one HBA),
-               but I haven't found a way how to get hostno
-               from the current kernel */
-            0,
-#endif
-            (id[0]>>16) & 0xff,
-            id[0] & 0xff,
-            (id[0]>>8) & 0xff
-        );
-        pfd = fopen("/proc/scsi/scsi","r");
-        if (pfd) {
-            while (fgets(buffer2, 2048, pfd)) {
-                if (!strcmp(buffer, buffer2)) {
-                    if (fgets(buffer2,2048,pfd)) {
-                        q = strstr(buffer2,"Vendor: ");
-                        if (q) {
-                            q += 8;
-                            vendor = q;
-                            q = strstr(q," ");
-                            *q++ = 0;   /* truncate vendor name */
-                            q = strstr(q,"Model: ");
-                            if (q) {
-                                *q = 0;
-                                q += 7;
-                                model = q;
-                                q = strstr(q," Rev: ");
-                                if (q) {
-                                    *q = 0;
-                                    for (i = 0; i < SIZE(sun_drives); i++) {
-                                        if (*sun_drives[i].vendor && strcasecmp(sun_drives[i].vendor, vendor))
-                                            continue;
-                                        if (!strstr(model, sun_drives[i].model))
-                                            continue;
-                                        printf(_("Autoconfigure found a %s%s%s\n"),sun_drives[i].vendor,(*sun_drives[i].vendor) ? " " : "",sun_drives[i].model);
-                                        p = sun_drives + i;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-            }
-            fclose(pfd);
-        }
-    }
-#endif
-    return p;
-}
-
-static void
-create_sunlabel(void)
-{
-    struct hd_geometry geometry;
-    unsigned int ndiv;
-    int i;
-    unsigned char c;
-    const struct sun_predefined_drives *p = NULL;
-
-    fprintf(stderr,
-        _("Building a new sun 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"));
-    sun_other_endian = BB_LITTLE_ENDIAN;
-    memset(MBRbuffer, 0, sizeof(MBRbuffer));
-    sunlabel->magic = SUN_SSWAP16(SUN_LABEL_MAGIC);
-    if (!floppy) {
-        puts(_("Drive type\n"
-         "   ?   auto configure\n"
-         "   0   custom (with hardware detected defaults)"));
-        for (i = 0; i < SIZE(sun_drives); i++) {
-            printf("   %c   %s%s%s\n",
-                i + 'a', sun_drives[i].vendor,
-                (*sun_drives[i].vendor) ? " " : "",
-                sun_drives[i].model);
-        }
-        while (1) {
-            c = read_char(_("Select type (? for auto, 0 for custom): "));
-            if (c >= 'a' && c < 'a' + SIZE(sun_drives)) {
-                p = sun_drives + c - 'a';
-                break;
-            } else if (c >= 'A' && c < 'A' + SIZE(sun_drives)) {
-                p = sun_drives + c - 'A';
-                break;
-            } else if (c == '0') {
-                break;
-            } else if (c == '?' && scsi_disk) {
-                p = sun_autoconfigure_scsi();
-                if (!p)
-                printf(_("Autoconfigure failed.\n"));
-                else
-                break;
-            }
-        }
-    }
-    if (!p || floppy) {
-        if (!ioctl(fd, HDIO_GETGEO, &geometry)) {
-            heads = geometry.heads;
-            sectors = geometry.sectors;
-            cylinders = geometry.cylinders;
-        } else {
-            heads = 0;
-            sectors = 0;
-            cylinders = 0;
-        }
-        if (floppy) {
-            sunlabel->nacyl = 0;
-            sunlabel->pcylcount = SUN_SSWAP16(cylinders);
-            sunlabel->rspeed = SUN_SSWAP16(300);
-            sunlabel->ilfact = SUN_SSWAP16(1);
-            sunlabel->sparecyl = 0;
-        } else {
-            heads = read_int(1,heads,1024,0,_("Heads"));
-            sectors = read_int(1,sectors,1024,0,_("Sectors/track"));
-        if (cylinders)
-            cylinders = read_int(1,cylinders-2,65535,0,_("Cylinders"));
-        else
-            cylinders = read_int(1,0,65535,0,_("Cylinders"));
-            sunlabel->nacyl = SUN_SSWAP16(read_int(0,2,65535,0, _("Alternate cylinders")));
-            sunlabel->pcylcount = SUN_SSWAP16(read_int(0,cylinders+SUN_SSWAP16(sunlabel->nacyl), 65535,0, _("Physical cylinders")));
-            sunlabel->rspeed = SUN_SSWAP16(read_int(1,5400,100000,0, _("Rotation speed (rpm)")));
-            sunlabel->ilfact = SUN_SSWAP16(read_int(1,1,32,0, _("Interleave factor")));
-            sunlabel->sparecyl = SUN_SSWAP16(read_int(0,0,sectors,0, _("Extra sectors per cylinder")));
-        }
-    } else {
-        sunlabel->sparecyl = SUN_SSWAP16(p->sparecyl);
-        sunlabel->ncyl = SUN_SSWAP16(p->ncyl);
-        sunlabel->nacyl = SUN_SSWAP16(p->nacyl);
-        sunlabel->pcylcount = SUN_SSWAP16(p->pcylcount);
-        sunlabel->ntrks = SUN_SSWAP16(p->ntrks);
-        sunlabel->nsect = SUN_SSWAP16(p->nsect);
-        sunlabel->rspeed = SUN_SSWAP16(p->rspeed);
-        sunlabel->ilfact = SUN_SSWAP16(1);
-        cylinders = p->ncyl;
-        heads = p->ntrks;
-        sectors = p->nsect;
-        puts(_("You may change all the disk params from the x menu"));
-    }
-
-    snprintf((char *)(sunlabel->info), sizeof(sunlabel->info),
-        "%s%s%s cyl %d alt %d hd %d sec %d",
-        p ? p->vendor : "", (p && *p->vendor) ? " " : "",
-        p ? p->model : (floppy ? _("3,5\" floppy") : _("Linux custom")),
-        cylinders, SUN_SSWAP16(sunlabel->nacyl), heads, sectors);
-
-    sunlabel->ntrks = SUN_SSWAP16(heads);
-    sunlabel->nsect = SUN_SSWAP16(sectors);
-    sunlabel->ncyl = SUN_SSWAP16(cylinders);
-    if (floppy)
-        set_sun_partition(0, 0, cylinders * heads * sectors, LINUX_NATIVE);
-    else {
-        if (cylinders * heads * sectors >= 150 * 2048) {
-            ndiv = cylinders - (50 * 2048 / (heads * sectors)); /* 50M swap */
-        } else
-            ndiv = cylinders * 2 / 3;
-        set_sun_partition(0, 0, ndiv * heads * sectors, LINUX_NATIVE);
-        set_sun_partition(1, ndiv * heads * sectors, cylinders * heads * sectors, LINUX_SWAP);
-        sunlabel->infos[1].flags |= 0x01; /* Not mountable */
-    }
-    set_sun_partition(2, 0, cylinders * heads * sectors, WHOLE_DISK);
-    {
-        unsigned short *ush = (unsigned short *)sunlabel;
-        unsigned short csum = 0;
-        while (ush < (unsigned short *)(&sunlabel->csum))
-            csum ^= *ush++;
-        sunlabel->csum = csum;
-    }
-
-    set_all_unchanged();
-    set_changed(0);
-    get_boot(create_empty_sun);
-}
-
-static void
-toggle_sunflags(int i, unsigned char mask)
-{
-    if (sunlabel->infos[i].flags & mask)
-        sunlabel->infos[i].flags &= ~mask;
-    else
-        sunlabel->infos[i].flags |= mask;
-    set_changed(i);
-}
-
-static void
-fetch_sun(uint *starts, uint *lens, uint *start, uint *stop)
-{
-    int i, continuous = 1;
-
-    *start = 0;
-    *stop = cylinders * heads * sectors;
-    for (i = 0; i < partitions; i++) {
-        if (sunlabel->partitions[i].num_sectors
-         && sunlabel->infos[i].id
-         && sunlabel->infos[i].id != WHOLE_DISK) {
-            starts[i] = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * heads * sectors;
-            lens[i] = SUN_SSWAP32(sunlabel->partitions[i].num_sectors);
-            if (continuous) {
-                if (starts[i] == *start)
-                    *start += lens[i];
-                else if (starts[i] + lens[i] >= *stop)
-                    *stop = starts[i];
-                else
-                    continuous = 0;
-                    /* There will be probably more gaps
-                      than one, so lets check afterwards */
-            }
-        } else {
-            starts[i] = 0;
-            lens[i] = 0;
-        }
-    }
-}
-
-static uint *verify_sun_starts;
-
-static int
-verify_sun_cmp(int *a, int *b)
-{
-    if (*a == -1) return 1;
-    if (*b == -1) return -1;
-    if (verify_sun_starts[*a] > verify_sun_starts[*b]) return 1;
-    return -1;
-}
-
-static void
-verify_sun(void)
-{
-    uint starts[8], lens[8], start, stop;
-    int i,j,k,starto,endo;
-    int array[8];
-
-    verify_sun_starts = starts;
-    fetch_sun(starts,lens,&start,&stop);
-    for (k = 0; k < 7; k++) {
-        for (i = 0; i < 8; i++) {
-            if (k && (lens[i] % (heads * sectors))) {
-                printf(_("Partition %d doesn't end on cylinder boundary\n"), i+1);
-            }
-            if (lens[i]) {
-                for (j = 0; j < i; j++)
-                    if (lens[j]) {
-                        if (starts[j] == starts[i]+lens[i]) {
-                            starts[j] = starts[i]; lens[j] += lens[i];
-                            lens[i] = 0;
-                        } else if (starts[i] == starts[j]+lens[j]){
-                            lens[j] += lens[i];
-                            lens[i] = 0;
-                        } else if (!k) {
-                            if (starts[i] < starts[j]+lens[j]
-                             && starts[j] < starts[i]+lens[i]) {
-                                starto = starts[i];
-                                if (starts[j] > starto)
-                                    starto = starts[j];
-                                endo = starts[i]+lens[i];
-                                if (starts[j]+lens[j] < endo)
-                                    endo = starts[j]+lens[j];
-                                printf(_("Partition %d overlaps with others in "
-                                    "sectors %d-%d\n"), i+1, starto, endo);
-                            }
-                        }
-                    }
-            }
-        }
-    }
-    for (i = 0; i < 8; i++) {
-        if (lens[i])
-            array[i] = i;
-        else
-            array[i] = -1;
-    }
-    qsort(array,SIZE(array),sizeof(array[0]),
-        (int (*)(const void *,const void *)) verify_sun_cmp);
-    if (array[0] == -1) {
-        printf(_("No partitions defined\n"));
-        return;
-    }
-    stop = cylinders * heads * sectors;
-    if (starts[array[0]])
-        printf(_("Unused gap - sectors 0-%d\n"),starts[array[0]]);
-    for (i = 0; i < 7 && array[i+1] != -1; i++) {
-        printf(_("Unused gap - sectors %d-%d\n"),starts[array[i]]+lens[array[i]],starts[array[i+1]]);
-    }
-    start = starts[array[i]] + lens[array[i]];
-    if (start < stop)
-        printf(_("Unused gap - sectors %d-%d\n"),start,stop);
-}
-
-static void
-add_sun_partition(int n, int sys)
-{
-    uint start, stop, stop2;
-    uint starts[8], lens[8];
-    int whole_disk = 0;
-
-    char mesg[256];
-    int i, first, last;
-
-    if (sunlabel->partitions[n].num_sectors && sunlabel->infos[n].id) {
-        printf(_("Partition %d is already defined.  Delete "
-            "it before re-adding it.\n"), n + 1);
-        return;
-    }
-
-    fetch_sun(starts,lens,&start,&stop);
-    if (stop <= start) {
-        if (n == 2)
-            whole_disk = 1;
-        else {
-            printf(_("Other partitions already cover the whole disk.\nDelete "
-                   "some/shrink them before retry.\n"));
-            return;
-        }
-    }
-    snprintf(mesg, sizeof(mesg), _("First %s"), str_units(SINGULAR));
-    while (1) {
-        if (whole_disk)
-            first = read_int(0, 0, 0, 0, mesg);
-        else
-            first = read_int(scround(start), scround(stop)+1,
-                     scround(stop), 0, mesg);
-        if (display_in_cyl_units)
-            first *= units_per_sector;
-        else
-            /* Starting sector has to be properly aligned */
-            first = (first + heads * sectors - 1) / (heads * sectors);
-        if (n == 2 && first != 0)
-            printf("\
-It is highly recommended that the third partition covers the whole disk\n\
-and is of type `Whole disk'\n");
-        /* ewt asks to add: "don't start a partition at cyl 0"
-           However, edmundo@rano.demon.co.uk writes:
-           "In addition to having a Sun partition table, to be able to
-           boot from the disc, the first partition, /dev/sdX1, must
-           start at cylinder 0. This means that /dev/sdX1 contains
-           the partition table and the boot block, as these are the
-           first two sectors of the disc. Therefore you must be
-           careful what you use /dev/sdX1 for. In particular, you must
-           not use a partition starting at cylinder 0 for Linux swap,
-           as that would overwrite the partition table and the boot
-           block. You may, however, use such a partition for a UFS
-           or EXT2 file system, as these file systems leave the first
-           1024 bytes undisturbed. */
-        /* On the other hand, one should not use partitions
-           starting at block 0 in an md, or the label will
-           be trashed. */
-        for (i = 0; i < partitions; i++)
-            if (lens[i] && starts[i] <= first && starts[i] + lens[i] > first)
-                break;
-        if (i < partitions && !whole_disk) {
-            if (n == 2 && !first) {
-                whole_disk = 1;
-                break;
-            }
-            printf(_("Sector %d is already allocated\n"), first);
-        } else
-            break;
-    }
-    stop = cylinders * heads * sectors;
-    stop2 = stop;
-    for (i = 0; i < partitions; i++) {
-        if (starts[i] > first && starts[i] < stop)
-            stop = starts[i];
-    }
-    snprintf(mesg, sizeof(mesg),
-        _("Last %s or +size or +sizeM or +sizeK"),
-        str_units(SINGULAR));
-    if (whole_disk)
-        last = read_int(scround(stop2), scround(stop2), scround(stop2),
-                0, mesg);
-    else if (n == 2 && !first)
-        last = read_int(scround(first), scround(stop2), scround(stop2),
-                scround(first), mesg);
-    else
-        last = read_int(scround(first), scround(stop), scround(stop),
-                scround(first), mesg);
-    if (display_in_cyl_units)
-        last *= units_per_sector;
-    if (n == 2 && !first) {
-        if (last >= stop2) {
-            whole_disk = 1;
-            last = stop2;
-        } else if (last > stop) {
-            printf(_("You haven't covered the whole disk with "
-                "the 3rd partition, but your value\n"
-                "%d %s covers some other partition. "
-                "Your entry has been changed\n"
-                "to %d %s\n"),
-                scround(last), str_units(SINGULAR),
-                scround(stop), str_units(SINGULAR));
-            last = stop;
-        }
-    } else if (!whole_disk && last > stop)
-        last = stop;
-
-    if (whole_disk)
-        sys = WHOLE_DISK;
-    set_sun_partition(n, first, last, sys);
-}
-
-static void
-sun_delete_partition(int i)
-{
-    unsigned int nsec;
-
-    if (i == 2
-     && sunlabel->infos[i].id == WHOLE_DISK
-     && !sunlabel->partitions[i].start_cylinder
-     && (nsec = SUN_SSWAP32(sunlabel->partitions[i].num_sectors)) == heads * sectors * cylinders)
-        printf(_("If you want to maintain SunOS/Solaris compatibility, "
-            "consider leaving this\n"
-            "partition as Whole disk (5), starting at 0, with %u "
-            "sectors\n"), nsec);
-    sunlabel->infos[i].id = 0;
-    sunlabel->partitions[i].num_sectors = 0;
-}
-
-static void
-sun_change_sysid(int i, int sys)
-{
-    if (sys == LINUX_SWAP && !sunlabel->partitions[i].start_cylinder) {
-        read_chars(
-            _("It is highly recommended that the partition at offset 0\n"
-            "is UFS, EXT2FS filesystem or SunOS swap. Putting Linux swap\n"
-            "there may destroy your partition table and bootblock.\n"
-            "Type YES if you're very sure you would like that partition\n"
-            "tagged with 82 (Linux swap): "));
-        if (strcmp (line_ptr, _("YES\n")))
-            return;
-    }
-    switch (sys) {
-    case SUNOS_SWAP:
-    case LINUX_SWAP:
-        /* swaps are not mountable by default */
-        sunlabel->infos[i].flags |= 0x01;
-        break;
-    default:
-        /* assume other types are mountable;
-           user can change it anyway */
-        sunlabel->infos[i].flags &= ~0x01;
-        break;
-    }
-    sunlabel->infos[i].id = sys;
-}
-
-static void
-sun_list_table(int xtra)
-{
-    int i, w;
-
-    w = strlen(disk_device);
-    if (xtra)
-        printf(
-        _("\nDisk %s (Sun disk label): %d heads, %d sectors, %d rpm\n"
-        "%d cylinders, %d alternate cylinders, %d physical cylinders\n"
-        "%d extra sects/cyl, interleave %d:1\n"
-        "%s\n"
-        "Units = %s of %d * 512 bytes\n\n"),
-            disk_device, heads, sectors, SUN_SSWAP16(sunlabel->rspeed),
-            cylinders, SUN_SSWAP16(sunlabel->nacyl),
-            SUN_SSWAP16(sunlabel->pcylcount),
-            SUN_SSWAP16(sunlabel->sparecyl),
-            SUN_SSWAP16(sunlabel->ilfact),
-            (char *)sunlabel,
-            str_units(PLURAL), units_per_sector);
-    else
-        printf(
-    _("\nDisk %s (Sun disk label): %d heads, %d sectors, %d cylinders\n"
-    "Units = %s of %d * 512 bytes\n\n"),
-            disk_device, heads, sectors, cylinders,
-            str_units(PLURAL), units_per_sector);
-
-    printf(_("%*s Flag    Start       End    Blocks   Id  System\n"),
-        w + 1, _("Device"));
-    for (i = 0 ; i < partitions; i++) {
-        if (sunlabel->partitions[i].num_sectors) {
-            uint32_t start = SUN_SSWAP32(sunlabel->partitions[i].start_cylinder) * heads * sectors;
-            uint32_t len = SUN_SSWAP32(sunlabel->partitions[i].num_sectors);
-            printf("%s %c%c %9ld %9ld %9ld%c  %2x  %s\n",
-                partname(disk_device, i+1, w),          /* device */            
-                (sunlabel->infos[i].flags & 0x01) ? 'u' : ' ',  /* flags */             
-                (sunlabel->infos[i].flags & 0x10) ? 'r' : ' ',              
-                (long) scround(start),                          /* start */             
-                (long) scround(start+len),                      /* end */               
-                (long) len / 2, len & 1 ? '+' : ' ',            /* odd flag on end */   
-                sunlabel->infos[i].id,                          /* type id */           
-                partition_type(sunlabel->infos[i].id));         /* type name */         
-        }
-    }
-}
-
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
-
-static void
-sun_set_alt_cyl(void)
-{
-    sunlabel->nacyl =
-        SUN_SSWAP16(read_int(0,SUN_SSWAP16(sunlabel->nacyl), 65535, 0,
-                _("Number of alternate cylinders")));
-}
-
-static void
-sun_set_ncyl(int cyl)
-{
-    sunlabel->ncyl = SUN_SSWAP16(cyl);
-}
-
-static void
-sun_set_xcyl(void)
-{
-    sunlabel->sparecyl =
-        SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->sparecyl), sectors, 0,
-                _("Extra sectors per cylinder")));
-}
-
-static void
-sun_set_ilfact(void)
-{
-    sunlabel->ilfact =
-        SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->ilfact), 32, 0,
-                _("Interleave factor")));
-}
-
-static void
-sun_set_rspeed(void)
-{
-    sunlabel->rspeed =
-        SUN_SSWAP16(read_int(1, SUN_SSWAP16(sunlabel->rspeed), 100000, 0,
-                _("Rotation speed (rpm)")));
-}
-
-static void
-sun_set_pcylcount(void)
-{
-    sunlabel->pcylcount =
-        SUN_SSWAP16(read_int(0, SUN_SSWAP16(sunlabel->pcylcount), 65535, 0,
-                _("Number of physical cylinders")));
-}
-#endif /* CONFIG_FEATURE_FDISK_ADVANCED */
-
-static void
-sun_write_table(void)
-{
-    unsigned short *ush = (unsigned short *)sunlabel;
-    unsigned short csum = 0;
-
-    while (ush < (unsigned short *)(&sunlabel->csum))
-        csum ^= *ush++;
-    sunlabel->csum = csum;
-    if (lseek(fd, 0, SEEK_SET) < 0)
-        fdisk_fatal(unable_to_seek);
-    if (write(fd, sunlabel, SECTOR_SIZE) != SECTOR_SIZE)
-        fdisk_fatal(unable_to_write);
-}
-#endif /* SUN_LABEL */
-
-/* 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;
-}
-
+STATIC_OSF void bsd_select(void);
+STATIC_OSF void xbsd_print_disklabel(int);
+#include "fdisk_osf.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
+fdisk_swap32(uint32_t x)
+{
+    return (x << 24) |
+           ((x & 0xFF00) << 8) |
+           ((x & 0xFF0000) >> 8) |
+           (x >> 24);
+}
+#endif
+
+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);
+#if ENABLE_FEATURE_FDISK_ADVANCED
+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 const char *sgi_get_bootfile(void);
+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);
+#include "fdisk_sgi.c"
+
+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 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);
+#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"
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
 /* 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
+store4_little_endian(unsigned char *cp, unsigned val)
+{
+    cp[0] = val;
+    cp[1] = val >> 8;
+    cp[2] = val >> 16;
+    cp[3] = val >> 24;
+}
+#endif /* FEATURE_FDISK_WRITABLE */
+
+static unsigned
 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)
+    return cp[0] + (cp[1] << 8) + (cp[2] << 16) + (cp[3] << 24);
+}
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static void
+set_start_sect(struct partition *p, unsigned start_sect)
 {
     store4_little_endian(p->start4, start_sect);
@@ -3315 +588 @@
 #endif
 
-static int32_t
+static unsigned
 get_start_sect(const struct partition *p)
 {
@@ -3321 +594 @@
 }
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static void
-set_nr_sects(struct partition *p, int32_t nr_sects)
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static void
+set_nr_sects(struct partition *p, unsigned nr_sects)
 {
     store4_little_endian(p->size4, nr_sects);
@@ -3329 +602 @@
 #endif
 
-static int32_t
+static unsigned
 get_nr_sects(const struct partition *p)
 {
@@ -3338 +611 @@
 static int type_open = O_RDWR;
 
-
 static int ext_index;               /* the prime extended partition */
-static int listing;                    /* no aborts for fdisk -l */
+static int listing;                 /* no aborts for fdisk -l */
 static int dos_compatible_flag = ~0;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_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)
-{
-    const char *message;
-
+static unsigned user_cylinders, user_heads, user_sectors;
+static unsigned pt_heads, pt_sectors;
+static unsigned kern_heads, kern_sectors;
+
+static ullong extended_offset;            /* offset of link pointers */
+static ullong total_number_of_sectors;
+
+static void fdisk_fatal(const char *why)
+{
     if (listing) {
         close(fd);
         longjmp(listingbuf, 1);
     }
-
-    switch (why) {
-    case unable_to_open:
-        message = "Unable to open %s\n";
-        break;
-    case unable_to_read:
-        message = "Unable to read %s\n";
-        break;
-    case unable_to_seek:
-        message = "Unable to seek on %s\n";
-        break;
-    case unable_to_write:
-        message = "Unable to write %s\n";
-        break;
-    case ioctl_error:
-        message = "BLKGETSIZE ioctl failed on %s\n";
-        break;
-    default:
-        message = "Fatal error\n";
-    }
-
-    fputc('\n', stderr);
-    fprintf(stderr, message, disk_device);
-    exit(1);
-}
-
-static void
-seek_sector(off_t secno)
-{
-    off_t offset = secno * sector_size;
-    if (lseek(fd, offset, SEEK_SET) == (off_t) -1)
+    bb_error_msg_and_die(why, disk_device);
+}
+
+static void
+seek_sector(ullong secno)
+{
+    secno *= sector_size;
+#if ENABLE_FDISK_SUPPORT_LARGE_DISKS
+    if (lseek64(fd, (off64_t)secno, SEEK_SET) == (off64_t) -1)
         fdisk_fatal(unable_to_seek);
-}
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static void
-write_sector(off_t secno, char *buf)
+#else
+    if (secno > MAXINT(off_t)
+     || lseek(fd, (off_t)secno, SEEK_SET) == (off_t) -1
+    ) {
+        fdisk_fatal(unable_to_seek);
+    }
+#endif
+}
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static void
+write_sector(ullong secno, char *buf)
 {
     seek_sector(secno);
@@ -3414 +663 @@
 /* Allocate a buffer and read a partition table sector */
 static void
-read_pte(struct pte *pe, off_t offset)
+read_pte(struct pte *pe, ullong offset)
 {
     pe->offset = offset;
-    pe->sectorbuffer = (char *) xmalloc(sector_size);
+    pe->sectorbuffer = xmalloc(sector_size);
     seek_sector(offset);
     if (read(fd, pe->sectorbuffer, sector_size) != sector_size)
         fdisk_fatal(unable_to_read);
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
     pe->changed = 0;
 #endif
@@ -3427 +676 @@
 }
 
-static unsigned int
+static unsigned
 get_partition_start(const struct pte *pe)
 {
@@ -3433 +682 @@
 }
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
 /*
  * Avoid warning about DOS partitions when no DOS partition was changed.
@@ -3453 +702 @@
 menu(void)
 {
-#ifdef CONFIG_FEATURE_SUN_LABEL
-    if (label_sun == current_label_type) {
-        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)"));
-#endif
-    } else
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-    if (label_sgi == current_label_type) {
-        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
-#endif
-#ifdef CONFIG_FEATURE_AIX_LABEL
-    if (label_aix == current_label_type) {
-        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
-#endif
-    {
-        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)"));
-#endif
-    }
-}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-
-
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+    puts("Command Action");
+    if (LABEL_IS_SUN) {
+        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
+    } 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 {
+        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 /* FEATURE_FDISK_WRITABLE */
+
+
+#if ENABLE_FEATURE_FDISK_ADVANCED
 static void
 xmenu(void)
 {
-#ifdef CONFIG_FEATURE_SUN_LABEL
-    if (label_sun == current_label_type) {
-    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
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-    if (label_sgi == current_label_type) {
-        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
-#endif
-#ifdef CONFIG_FEATURE_AIX_LABEL
-    if (label_aix == current_label_type) {
-        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
-#endif
-    {
-        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 */
-#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("Command Action");
+    if (LABEL_IS_SUN) {
+        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
+        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 */
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static const struct systypes *
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static const char *const *
 get_sys_types(void)
 {
     return (
-#ifdef CONFIG_FEATURE_SUN_LABEL
-        label_sun == current_label_type ? sun_sys_types :
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-        label_sgi == current_label_type ? sgi_sys_types :
-#endif
+        LABEL_IS_SUN ? sun_sys_types :
+        LABEL_IS_SGI ? sgi_sys_types :
         i386_sys_types);
 }
 #else
 #define get_sys_types() i386_sys_types
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-
-static const char *partition_type(unsigned char type)
+#endif /* FEATURE_FDISK_WRITABLE */
+
+static const char *
+partition_type(unsigned char type)
 {
     int i;
-    const struct systypes *types = get_sys_types();
-
-    for (i = 0; types[i].name; i++)
-        if ((unsigned char )types[i].name[0] == type)
-            return types[i].name + 1;
-
-    return _("Unknown");
-}
-
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+    const char *const *types = get_sys_types();
+
+    for (i = 0; types[i]; i++)
+        if ((unsigned char)types[i][0] == type)
+            return types[i] + 1;
+
+    return "Unknown";
+}
+
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
 static int
 get_sysid(int i)
 {
-    return (
-#ifdef CONFIG_FEATURE_SUN_LABEL
-        label_sun == current_label_type ? sunlabel->infos[i].id :
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-        label_sgi == current_label_type ? sgi_get_sysid(i) :
-#endif
-        ptes[i].part_table->sys_ind);
-}
-
-void list_types(const struct systypes *sys)
-{
-    uint last[4], done = 0, next = 0, size;
+    return LABEL_IS_SUN ? sunlabel->infos[i].id :
+            (LABEL_IS_SGI ? sgi_get_sysid(i) :
+                ptes[i].part_table->sys_ind);
+}
+
+static void
+list_types(const char *const *sys)
+{
+    enum { COLS = 3 };
+
+    unsigned last[COLS];
+    unsigned done, next, size;
     int i;
 
-    for (i = 0; sys[i].name; i++);
-    size = i;
-
-    for (i = 3; i >= 0; i--)
-        last[3 - i] = done += (size + i - done) / (i + 1);
-    i = done = 0;
-
+    for (size = 0; sys[size]; size++) /* */;
+
+    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 {
-        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;
-        if (i > 3 || next >= last[i]) {
+        if (i >= COLS || next >= last[i]) {
             i = 0;
             next = ++done;
@@ -3680 +895 @@
     putchar('\n');
 }
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
 
 static int
@@ -3698 +913 @@
 }
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static void
-set_partition(int i, int doext, off_t start, off_t stop, int sysid)
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static void
+set_partition(int i, int doext, ullong start, ullong stop, int sysid)
 {
     struct partition *p;
-    off_t offset;
+    ullong offset;
 
     if (doext) {
@@ -3727 +942 @@
 
 static int
-test_c(const char **m, const char *mesg)
-{
-    int val = 0;
-    if (!*m)
-        fprintf(stderr, _("You must set"));
-    else {
-        fprintf(stderr, " %s", *m);
-        val = 1;
-    }
-    *m = mesg;
-    return val;
-}
-
-static int
 warn_geometry(void)
 {
-    const char *m = NULL;
-    int prev = 0;
-
+    if (heads && sectors && cylinders)
+        return 0;
+
+    printf("Unknown value(s) for:");
     if (!heads)
-        prev = test_c(&m, _("heads"));
+        printf(" heads");
     if (!sectors)
-        prev = test_c(&m, _("sectors"));
+        printf(" sectors");
     if (!cylinders)
-        prev = test_c(&m, _("cylinders"));
-    if (!m)
-        return 0;
-
-    fprintf(stderr, "%s%s.\n"
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-            "You can do this from the extra functions menu.\n"
-#endif
-        , prev ? _(" and ") : " ", m);
-
+        printf(" cylinders");
+    printf(
+#if ENABLE_FEATURE_FDISK_WRITABLE
+        " (settable in the extra functions menu)"
+#endif
+        "\n");
     return 1;
 }
 
-static void update_units(void)
+static void
+update_units(void)
 {
     int cyl_units = heads * sectors;
@@ -3774 +973 @@
 }
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
 static void
 warn_cylinders(void)
 {
-    if (label_dos == current_label_type && cylinders > 1024 && !nowarn)
-        fprintf(stderr, _("\n"
+    if (LABEL_IS_DOS && cylinders > 1024 && !nowarn)
+        printf("\n"
 "The number of cylinders for this disk is set to %d.\n"
 "There is nothing wrong with that, but this is larger than 1024,\n"
@@ -3785 +984 @@
 "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"),
+"   (e.g., DOS FDISK, OS/2 FDISK)\n",
             cylinders);
 }
@@ -3803 +1002 @@
     p = pex->part_table;
     if (!get_start_sect(p)) {
-        fprintf(stderr,
-            _("Bad offset in primary extended partition\n"));
+        printf("Bad offset in primary extended partition\n");
         return;
     }
@@ -3814 +1012 @@
             /* This is not a Linux restriction, but
                this program uses arrays of size MAXIMUM_PARTS.
-               Do not try to `improve' this test. */
+               Do not try to 'improve' this test. */
             struct pte *pre = &ptes[partitions-1];
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-            fprintf(stderr,
-                _("Warning: deleting partitions after %d\n"),
+#if ENABLE_FEATURE_FDISK_WRITABLE
+            printf("Warning: deleting partitions after %d\n",
                 partitions);
             pre->changed = 1;
@@ -3835 +1032 @@
             if (IS_EXTENDED(p->sys_ind)) {
                 if (pe->ext_pointer)
-                    fprintf(stderr,
-                        _("Warning: extra link "
-                          "pointer in partition table"
-                          " %d\n"), partitions + 1);
+                    printf("Warning: extra link "
+                        "pointer in partition table"
+                        " %d\n", partitions + 1);
                 else
                     pe->ext_pointer = p;
             } else if (p->sys_ind) {
                 if (pe->part_table)
-                    fprintf(stderr,
-                        _("Warning: ignoring extra "
+                    printf("Warning: ignoring extra "
                           "data in partition table"
-                          " %d\n"), partitions + 1);
+                          " %d\n", partitions + 1);
                 else
                     pe->part_table = p;
@@ -3870 +1065 @@
     }
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
     /* remove empty links */
  remove:
@@ -3876 +1071 @@
         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)
+         && (partitions > 5 || ptes[4].part_table->sys_ind)
+        ) {
+            printf("Omitting empty partition (%d)\n", i+1);
             delete_partition(i);
             goto remove;    /* numbering changed */
@@ -3886 +1082 @@
 }
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
 static void
 create_doslabel(void)
@@ -3892 +1088 @@
     int i;
 
-    fprintf(stderr,
-    _("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
+#if ENABLE_FEATURE_OSF_LABEL
     possibly_osf_label = 0;
 #endif
@@ -3912 +1105 @@
     get_boot(create_empty_dos);
 }
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
+#endif /* FEATURE_FDISK_WRITABLE */
 
 static void
@@ -3922 +1115 @@
             sector_size = arg;
         if (sector_size != DEFAULT_SECTOR_SIZE)
-            printf(_("Note: sector size is %d (not %d)\n"),
+            printf("Note: sector size is %d (not %d)\n",
                    sector_size, DEFAULT_SECTOR_SIZE);
     }
 }
 
-static inline void
+static void
 get_kernel_geometry(void)
 {
@@ -3976 +1169 @@
 {
     int sec_fac;
-    unsigned long long bytes;       /* really u64 */
+    uint64_t v64;
 
     get_sectorsize();
     sec_fac = sector_size / 512;
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
     guess_device_type();
 #endif
@@ -3996 +1189 @@
         pt_sectors ? pt_sectors :
         kern_sectors ? kern_sectors : 63;
-    if (ioctl(fd, BLKGETSIZE64, &bytes) == 0) {
-        /* got bytes */
+    if (ioctl(fd, BLKGETSIZE64, &v64) == 0) {
+        /* got bytes, convert to 512 byte sectors */
+        total_number_of_sectors = (v64 >> 9);
     } else {
-        unsigned long longsectors;
-
-    if (ioctl(fd, BLKGETSIZE, &longsectors))
-        longsectors = 0;
-            bytes = ((unsigned long long) longsectors) << 9;
-    }
-
-    total_number_of_sectors = (bytes >> 9);
+        unsigned long longsectors; /* need temp of type long */
+        if (ioctl(fd, BLKGETSIZE, &longsectors))
+            longsectors = 0;
+        total_number_of_sectors = longsectors;
+    }
 
     sector_offset = 1;
@@ -4037 +1228 @@
         pe->offset = 0;
         pe->sectorbuffer = MBRbuffer;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
         pe->changed = (what == create_empty_dos);
 #endif
     }
 
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
     if (what == create_empty_sun && check_sun_label())
         return 0;
@@ -4049 +1240 @@
     memset(MBRbuffer, 0, 512);
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_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) {
+    fd = open(disk_device, type_open);
+    if (fd < 0) {
+        fd = open(disk_device, O_RDONLY);
+        if (fd < 0) {
             if (what == try_only)
                 return 1;
             fdisk_fatal(unable_to_open);
         } else
-            printf(_("You will not be able to write "
-                "the partition table.\n"));
+            printf("You will not be able to write "
+                "the partition table\n");
     }
 
@@ -4069 +1262 @@
     }
 #else
-    if ((fd = open(disk_device, O_RDONLY)) < 0)
+    fd = open(disk_device, O_RDONLY);
+    if (fd < 0)
         return 1;
     if (512 != read(fd, MBRbuffer, 512))
@@ -4079 +1273 @@
     update_units();
 
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
     if (check_sun_label())
         return 0;
 #endif
 
-#ifdef CONFIG_FEATURE_SGI_LABEL
+#if ENABLE_FEATURE_SGI_LABEL
     if (check_sgi_label())
         return 0;
 #endif
 
-#ifdef CONFIG_FEATURE_AIX_LABEL
+#if ENABLE_FEATURE_AIX_LABEL
     if (check_aix_label())
         return 0;
 #endif
 
-#ifdef CONFIG_FEATURE_OSF_LABEL
+#if ENABLE_FEATURE_OSF_LABEL
     if (check_osf_label()) {
         possibly_osf_label = 1;
@@ -4101 +1295 @@
             return 0;
         }
-        printf(_("This disk has both DOS and BSD magic.\n"
-             "Give the 'b' command to go to BSD mode.\n"));
-    }
-#endif
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+        printf("This disk has both DOS and BSD magic.\n"
+             "Give the 'b' command to go to BSD mode.\n");
+    }
+#endif
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
  got_dos_table:
 #endif
 
     if (!valid_part_table_flag(MBRbuffer)) {
-#ifndef CONFIG_FEATURE_FDISK_WRITABLE
+#if !ENABLE_FEATURE_FDISK_WRITABLE
         return -1;
 #else
         switch (what) {
         case fdisk:
-            fprintf(stderr,
-                _("Device contains neither a valid DOS "
+            printf("Device contains neither a valid DOS "
                   "partition table, nor Sun, SGI or OSF "
-                  "disklabel\n"));
+                  "disklabel\n");
 #ifdef __sparc__
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
             create_sunlabel();
 #endif
@@ -4131 +1324 @@
             return -1;
         case create_empty_dos:
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
         case create_empty_sun:
 #endif
             break;
         default:
-            fprintf(stderr, _("Internal error\n"));
-            exit(1);
-        }
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-    }
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+            bb_error_msg_and_die("internal error");
+        }
+#endif /* FEATURE_FDISK_WRITABLE */
+    }
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
     warn_cylinders();
 #endif
@@ -4152 +1344 @@
         if (IS_EXTENDED(pe->part_table->sys_ind)) {
             if (partitions != 4)
-                fprintf(stderr, _("Ignoring extra extended "
-                    "partition %d\n"), i + 1);
+                printf("Ignoring extra extended "
+                    "partition %d\n", i + 1);
             else
                 read_extended(i);
@@ -4163 +1355 @@
 
         if (!valid_part_table_flag(pe->sectorbuffer)) {
-            fprintf(stderr,
-                _("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
+            printf("Warning: invalid flag 0x%02x,0x%02x of partition "
+                "table %d will be corrected by w(rite)\n",
+                pe->sectorbuffer[510],
+                pe->sectorbuffer[511],
+                i + 1);
+#if ENABLE_FEATURE_FDISK_WRITABLE
             pe->changed = 1;
 #endif
@@ -4176 +1369 @@
 }
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
 /*
  * Print the message MESG, then read an integer between LOW and HIGH (inclusive).
@@ -4184 +1377 @@
  * 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)
-{
-    uint i;
+static unsigned
+read_int(unsigned low, unsigned dflt, unsigned high, unsigned base, const char *mesg)
+{
+    unsigned i;
     int default_ok = 1;
-    static char *ms = NULL;
-    static int mslen = 0;
-
-    if (!ms || strlen(mesg)+100 > mslen) {
-        mslen = strlen(mesg)+200;
-        ms = xrealloc(ms,mslen);
-    }
-
-    if (dflt < low || dflt > high)
+    const char *fmt = "%s (%u-%u, default %u): ";
+
+    if (dflt < low || dflt > high) {
+        fmt = "%s (%u-%u): ";
         default_ok = 0;
-
-    if (default_ok)
-        snprintf(ms, mslen, _("%s (%u-%u, default %u): "),
-             mesg, low, high, dflt);
-    else
-        snprintf(ms, mslen, "%s (%u-%u): ", mesg, low, high);
+    }
 
     while (1) {
@@ -4210 +1393 @@
 
         /* ask question and read answer */
-        while (read_chars(ms) != '\n' && !isdigit(*line_ptr)
-         && *line_ptr != '-' && *line_ptr != '+')
-            continue;
+        do {
+            printf(fmt, mesg, low, high, dflt);
+            read_maybe_empty("");
+        } while (*line_ptr != '\n' && !isdigit(*line_ptr)
+         && *line_ptr != '-' && *line_ptr != '+');
 
         if (*line_ptr == '+' || *line_ptr == '-') {
@@ -4218 +1403 @@
             int absolute = 0;
 
-            i = atoi(line_ptr+1);
+            i = atoi(line_ptr + 1);
 
             while (isdigit(*++line_ptr))
@@ -4247 +1432 @@
             }
             if (absolute) {
-                unsigned long long bytes;
+                ullong bytes;
                 unsigned long unit;
 
-                bytes = (unsigned long long) i * absolute;
+                bytes = (ullong) i * absolute;
                 unit = sector_size * units_per_sector;
                 bytes += unit/2; /* round */
@@ -4266 +1451 @@
             }
         }
-        if (use_default)
-            printf(_("Using default value %u\n"), i = dflt);
+        if (use_default) {
+            i = dflt;
+            printf("Using default value %u\n", i);
+        }
         if (i >= low && i <= high)
             break;
-        else
-            printf(_("Value out of range.\n"));
+        printf("Value is out of range\n");
     }
     return i;
@@ -4282 +1468 @@
     int 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) {
-        if (
-            (
-                label_sun != current_label_type && 
-                label_sgi != current_label_type && 
-                !pe->part_table->sys_ind
-            )
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            || (
-                label_sun == current_label_type &&
-                (
-                    !sunlabel->partitions[i].num_sectors
-                    || !sunlabel->infos[i].id
-                )
-            )
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            || (
-                label_sgi == current_label_type &&
-                 !sgi_get_num_sectors(i)
-            )
-#endif
-        ){
-            fprintf(stderr,
-                _("Warning: partition %d has empty type\n"),
-                i+1
-            );
+        if ((!LABEL_IS_SUN && !LABEL_IS_SGI && !pe->part_table->sys_ind)
+         || (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);
         }
     }
@@ -4334 +1499 @@
     }
     if (pno >= 0) {
-        printf(_("Selected partition %d\n"), pno+1);
+        printf("Selected partition %d\n", pno+1);
         return pno;
     }
-    printf(_("No partition is defined yet!\n"));
+    printf("No partition is defined yet!\n");
     return -1;
 
@@ -4361 +1526 @@
     }
     if (pno >= 0) {
-        printf(_("Selected partition %d\n"), pno+1);
+        printf("Selected partition %d\n", pno+1);
         return pno;
     }
-    printf(_("All primary partitions have been defined already!\n"));
+    printf("All primary partitions have been defined already!\n");
     return -1;
 
@@ -4372 +1537 @@
 
 
-void change_units(void)
+static void
+change_units(void)
 {
     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));
 }
@@ -4387 +1553 @@
 
     if (IS_EXTENDED(p->sys_ind) && !p->boot_ind)
-        fprintf(stderr,
-            _("WARNING: Partition %d is an extended partition\n"),
-            i + 1);
+        printf("WARNING: Partition %d is an extended partition\n", i + 1);
     p->boot_ind = (p->boot_ind ? 0 : ACTIVE_FLAG);
     pe->changed = 1;
@@ -4400 +1564 @@
     if (dos_compatible_flag) {
         sector_offset = sectors;
-        printf(_("DOS Compatibility flag is set\n"));
-    }
-    else {
+        printf("DOS Compatibility flag is set\n");
+    } else {
         sector_offset = 1;
-        printf(_("DOS Compatibility flag is not set\n"));
+        printf("DOS Compatibility flag is not set\n");
     }
 }
@@ -4423 +1586 @@
     pe->changed = 1;
 
-#ifdef CONFIG_FEATURE_SUN_LABEL
-    if (label_sun == current_label_type) {
+    if (LABEL_IS_SUN) {
         sun_delete_partition(i);
         return;
     }
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-    if (label_sgi == current_label_type) {
+    if (LABEL_IS_SGI) {
         sgi_delete_partition(i);
         return;
     }
-#endif
 
     if (i < 4) {
@@ -4491 +1650 @@
     struct partition *p;
 
-#ifdef CONFIG_FEATURE_SGI_LABEL
     /* If sgi_label then don't use get_existing_partition,
        let the user select a partition, since get_existing_partition()
        only works for Linux like partition tables. */
-    if (label_sgi != current_label_type) {
+    if (!LABEL_IS_SGI) {
         i = get_existing_partition(0, partitions);
     } else {
         i = get_partition(0, partitions);
     }
-#else
-    i = get_existing_partition(0, partitions);
-#endif
     if (i == -1)
         return;
@@ -4510 +1665 @@
     /* if changing types T to 0 is allowed, then
        the reverse change must be allowed, too */
-    if (!sys && label_sgi != current_label_type &&
-        label_sun != current_label_type && !get_nr_sects(p))
-    {
-        printf(_("Partition %d does not exist yet!\n"), i + 1);
-    }else{
-        while (1) {
-        sys = read_hex (get_sys_types());
-
-        if (!sys && label_sgi != current_label_type &&
-            label_sun != current_label_type)
-        {
-            printf(_("Type 0 means free space to many systems\n"
+    if (!sys && !LABEL_IS_SGI && !LABEL_IS_SUN && !get_nr_sects(p)) {
+        printf("Partition %d does not exist yet!\n", i + 1);
+        return;
+    }
+    while (1) {
+        sys = read_hex(get_sys_types());
+
+        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"));
+                   "type 0 is probably unwise.\n");
             /* break; */
         }
 
-        if (label_sun != current_label_type && label_sgi != current_label_type) {
+        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"));
+                printf("You cannot change a partition into"
+                       " an extended one or vice versa\n");
                 break;
             }
@@ -4538 +1688 @@
 
         if (sys < 256) {
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            if (label_sun == current_label_type && i == 2 && sys != WHOLE_DISK)
-                printf(_("Consider leaving partition 3 "
+#if ENABLE_FEATURE_SUN_LABEL
+            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"));
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            if (label_sgi == current_label_type &&
+                       "even Linux likes it\n\n");
+#endif
+#if ENABLE_FEATURE_SGI_LABEL
+            if (LABEL_IS_SGI &&
                 (
-                    (i == 10 && sys != ENTIRE_DISK) ||
+                    (i == 10 && sys != SGI_ENTIRE_DISK) ||
                     (i == 8 && sys != 0)
                 )
-            ){
-                printf(_("Consider leaving partition 9 "
+            ) {
+                printf("Consider leaving partition 9 "
                        "as volume header (0),\nand "
                        "partition 11 as entire volume (6)"
-                       "as IRIX expects it.\n\n"));
+                       "as IRIX expects it\n\n");
             }
 #endif
             if (sys == origsys)
                 break;
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            if (label_sun == current_label_type) {
+            if (LABEL_IS_SUN) {
                 sun_change_sysid(i, sys);
-            } else
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            if (label_sgi == current_label_type) {
+            } else if (LABEL_IS_SGI) {
                 sgi_change_sysid(i, sys);
             } else
-#endif
                 p->sys_ind = sys;
 
-            printf(_("Changed system type of partition %d "
-                "to %x (%s)\n"), i + 1, sys,
+            printf("Changed system type of partition %d "
+                "to %x (%s)\n", i + 1, sys,
                 partition_type(sys));
             ptes[i].changed = 1;
@@ -4581 +1726 @@
             break;
         }
-        }
-    }
-}
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-
-
-/* check_consistency() and long2chs() added Sat Mar 6 12:28:16 1993,
+    }
+}
+#endif /* FEATURE_FDISK_WRITABLE */
+
+
+/* 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.
@@ -4593 +1737 @@
 
 static void
-long2chs(ulong ls, uint *c, uint *h, uint *s)
+linear2chs(unsigned ls, unsigned *c, unsigned *h, unsigned *s)
 {
     int spc = heads * sectors;
@@ -4606 +1750 @@
 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))
@@ -4625 +1769 @@
 
 /* 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) */
-    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? */
     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);
+        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);
     }
 
 /* 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 0
-/* Beginning on cylinder boundary? */
-    if (pbh != !pbc || pbs != 1) {
-        printf(_("Partition %i does not start on cylinder "
-            "boundary:\n"), partition + 1);
-        printf(_("     phys=(%d, %d, %d) "), pbc, pbh, pbs);
-        printf(_("should be (%d, %d, 1)\n"), pbc, !pbc);
-    }
-#endif
+        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);
+    }
 
 /* Ending on cylinder boundary? */
     if (peh != (heads - 1) || pes != sectors) {
-        printf(_("Partition %i does not end on cylinder boundary.\n"),
+        printf("Partition %i does not end on cylinder boundary\n",
             partition + 1);
-#if 0
-        printf(_("     phys=(%d, %d, %d) "), pec, peh, pes);
-        printf(_("should be (%d, %d, %d)\n"),
-        pec, heads - 1, sectors);
-#endif
     }
 }
@@ -4675 +1804 @@
 
     if (megabytes < 10000)
-        printf(_("\nDisk %s: %ld MB, %lld bytes\n"),
+        printf("\nDisk %s: %ld MB, %lld bytes\n",
                disk_device, megabytes, bytes);
     else
-        printf(_("\nDisk %s: %ld.%ld GB, %lld bytes\n"),
+        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"),
+    printf("%d heads, %d sectors/track, %d cylinders",
            heads, sectors, cylinders);
     if (units_per_sector == 1)
-        printf(_(", total %llu sectors"),
+        printf(", total %llu sectors",
                total_number_of_sectors / (sector_size/512));
-    printf(_("\nUnits = %s of %d * %d = %d bytes\n\n"),
+    printf("\nUnits = %s of %d * %d = %d bytes\n\n",
            str_units(PLURAL),
            units_per_sector, sector_size, units_per_sector * sector_size);
@@ -4700 +1829 @@
     const struct pte *pe;
     const struct partition *p;
-    off_t last_p_start_pos = 0, p_start_pos;
+    ullong last_p_start_pos = 0, p_start_pos;
     int i, last_i = 0;
 
-    for (i = 0 ; i < partitions; i++) {
+    for (i = 0; i < partitions; i++) {
         if (i == 4) {
             last_i = 4;
@@ -4725 +1854 @@
 }
 
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED
 /*
  * Fix the chain of logicals.
@@ -4798 +1927 @@
 
     if (!wrong_p_order(NULL)) {
-        printf(_("Nothing to do. Ordering is correct already.\n\n"));
+        printf("Ordering is already correct\n\n");
         return;
     }
@@ -4837 +1966 @@
     int i, w;
 
-#ifdef CONFIG_FEATURE_SUN_LABEL
-    if (label_sun == current_label_type) {
+    if (LABEL_IS_SUN) {
         sun_list_table(xtra);
         return;
     }
-#endif
-
-#ifdef CONFIG_FEATURE_SGI_LABEL
-    if (label_sgi == current_label_type) {
+    if (LABEL_IS_SUN) {
         sgi_list_table(xtra);
         return;
     }
-#endif
 
     list_disk_geometry();
 
-#ifdef CONFIG_FEATURE_OSF_LABEL
-    if (label_osf == current_label_type) {
+    if (LABEL_IS_OSF) {
         xbsd_print_disklabel(xtra);
         return;
     }
-#endif
 
     /* Heuristic: we list partition 3 of /dev/foo as /dev/foo3,
@@ -4869 +1991 @@
         w = 5;
 
-    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++) {
         const struct pte *pe = &ptes[i];
+        ullong psects;
+        ullong pblocks;
+        unsigned podd;
 
         p = pe->part_table;
-        if (p && !is_cleared_partition(p)) {
-            off_t psects = get_nr_sects(p);
-            off_t pblocks = psects;
-            unsigned int podd = 0;
-
-            if (sector_size < 1024) {
-                pblocks /= (1024 / sector_size);
-                podd = psects % (1024 / sector_size);
-            }
-            if (sector_size > 1024)
-                pblocks *= (sector_size / 1024);
-            printf(
-                "%s  %c %11llu %11llu %11llu%c  %2x  %s\n",
+        if (!p || is_cleared_partition(p))
+            continue;
+
+        psects = get_nr_sects(p);
+        pblocks = psects;
+        podd = 0;
+
+        if (sector_size < 1024) {
+            pblocks /= (1024 / sector_size);
+            podd = psects % (1024 / sector_size);
+        }
+        if (sector_size > 1024)
+            pblocks *= (sector_size / 1024);
+
+        printf("%s  %c %11llu %11llu %11llu%c %2x %s\n",
             partname(disk_device, i+1, w+2),
-/* boot flag */         !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG
-            ? '*' : '?',
-/* start */             (unsigned long long) cround(get_partition_start(pe)),
-/* end */               (unsigned long long) cround(get_partition_start(pe) + psects
+            !p->boot_ind ? ' ' : p->boot_ind == ACTIVE_FLAG /* boot flag */
+                ? '*' : '?',
+            (ullong) cround(get_partition_start(pe)),           /* start */
+            (ullong) cround(get_partition_start(pe) + psects    /* end */
                 - (psects ? 1 : 0)),
-/* odd flag on end */   (unsigned long long) pblocks, podd ? '+' : ' ',
-/* type id */           p->sys_ind,
-/* type name */         partition_type(p->sys_ind));
-            check_consistency(p, i);
-        }
+            (ullong) pblocks, podd ? '+' : ' ', /* odd flag on end */
+            p->sys_ind,                                     /* type id */
+            partition_type(p->sys_ind));                    /* type name */
+
+        check_consistency(p, i);
     }
 
@@ -4905 +2033 @@
     /* partition table entries are not checked for correct order if this
        is a sgi, sun or aix labeled disk... */
-    if (label_dos == current_label_type && wrong_p_order(NULL)) {
+    if (LABEL_IS_DOS && wrong_p_order(NULL)) {
         /* FIXME */
-        printf(_("\nPartition table entries are not in disk order\n"));
-    }
-}
-
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+        printf("\nPartition table entries are not in disk order\n");
+    }
+}
+
+#if ENABLE_FEATURE_FDISK_ADVANCED
 static void
 x_list_table(int extend)
@@ -4919 +2047 @@
     int i;
 
-    printf(_("\nDisk %s: %d heads, %d sectors, %d cylinders\n\n"),
+    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("Nr AF  Hd Sec  Cyl  Hd Sec  Cyl      Start       Size ID\n");
+    for (i = 0; i < partitions; i++) {
         pe = &ptes[i];
         p = (extend ? pe->ext_pointer : pe->part_table);
@@ -4940 +2068 @@
 #endif
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-static void
-fill_bounds(off_t *first, off_t *last)
+#if ENABLE_FEATURE_FDISK_WRITABLE
+static void
+fill_bounds(ullong *first, ullong *last)
 {
     int i;
@@ -4961 +2089 @@
 
 static void
-check(int n, uint h, uint s, uint c, off_t start)
-{
-    off_t total, real_s, real_c;
+check(int n, unsigned h, unsigned s, unsigned c, ullong start)
+{
+    ullong total, real_s, real_c;
 
     real_s = sector(s) - 1;
@@ -4969 +2097 @@
     total = (real_c * sectors + real_s) * heads + h;
     if (!total)
-        fprintf(stderr, _("Warning: partition %d contains sector 0\n"), n);
+        printf("Partition %d contains sector 0\n", n);
     if (h >= heads)
-        fprintf(stderr,
-            _("Partition %d: head %d greater than maximum %d\n"),
+        printf("Partition %d: head %d greater than maximum %d\n",
             n, h + 1, heads);
     if (real_s >= sectors)
-        fprintf(stderr, _("Partition %d: sector %d greater than "
-            "maximum %d\n"), n, s, sectors);
+        printf("Partition %d: sector %d greater than "
+            "maximum %d\n", n, s, sectors);
     if (real_c >= cylinders)
-        fprintf(stderr, _("Partitions %d: cylinder %llu greater than "
-            "maximum %d\n"), n, (unsigned long long)real_c + 1, cylinders);
+        printf("Partition %d: cylinder %llu greater than "
+            "maximum %d\n", n, real_c + 1, cylinders);
     if (cylinders <= 1024 && start != total)
-        fprintf(stderr,
-            _("Partition %d: previous sectors %llu disagrees with "
-            "total %llu\n"), n, (unsigned long long)start, (unsigned long long)total);
+        printf("Partition %d: previous sectors %llu disagrees with "
+            "total %llu\n", n, start, total);
 }
 
@@ -4990 +2116 @@
 {
     int i, j;
-    uint total = 1;
-    off_t first[partitions], last[partitions];
+    unsigned total = 1;
+    ullong first[partitions], last[partitions];
     struct partition *p;
 
@@ -4997 +2123 @@
         return;
 
-#ifdef CONFIG_FEATURE_SUN_LABEL
-    if (label_sun == current_label_type) {
+    if (LABEL_IS_SUN) {
         verify_sun();
         return;
     }
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-    if (label_sgi == current_label_type) {
+    if (LABEL_IS_SGI) {
         verify_sgi(1);
         return;
     }
-#endif
 
     fill_bounds(first, last);
@@ -5018 +2140 @@
             check_consistency(p, i);
             if (get_partition_start(pe) < first[i])
-                printf(_("Warning: bad start-of-data in "
-                    "partition %d\n"), i + 1);
+                printf("Warning: bad start-of-data in "
+                    "partition %d\n", i + 1);
             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 %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];
+                }
             }
         }
@@ -5038 +2161 @@
     if (extended_offset) {
         struct pte *pex = &ptes[ext_index];
-        off_t e_last = get_start_sect(pex->part_table) +
+        ullong e_last = get_start_sect(pex->part_table) +
             get_nr_sects(pex->part_table) - 1;
 
@@ -5046 +2169 @@
             if (!p->sys_ind) {
                 if (i != 4 || i + 1 < partitions)
-                    printf(_("Warning: partition %d "
-                        "is empty\n"), i + 1);
+                    printf("Warning: partition %d "
+                        "is empty\n", i + 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);
             }
-            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);
+        printf("Total allocated sectors %d greater than the maximum "
+            "%d\n", total, heads * sectors * cylinders);
+    else {
+        total = heads * sectors * cylinders - total;
+        if (total != 0)
+            printf("%d unallocated sectors\n", total);
+    }
 }
 
@@ -5070 +2195 @@
     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];
+    ullong limit, temp;
+    ullong start, stop = 0;
+    ullong first[partitions], last[partitions];
 
     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;
     }
@@ -5083 +2207 @@
         start = sector_offset;
         if (display_in_cyl_units || !total_number_of_sectors)
-            llimit = heads * sectors * cylinders - 1;
+            limit = (ullong) heads * sectors * cylinders - 1;
         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;
@@ -5102 +2223 @@
             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;
@@ -5117 +2238 @@
             break;
         if (start >= temp+units_per_sector && num_read) {
-            printf(_("Sector %llu is already allocated\n"), (unsigned long long)temp);
+            printf("Sector %lld is already allocated\n", temp);
             temp = start;
             num_read = 0;
         }
         if (!num_read && start == temp) {
-            off_t saved_start;
+            ullong saved_start;
 
             saved_start = start;
@@ -5154 +2275 @@
     }
     if (start > limit) {
-        printf(_("No free sectors available\n"));
+        printf("No free sectors available\n");
         if (n > 4)
             partitions--;
@@ -5163 +2284 @@
     } else {
         snprintf(mesg, sizeof(mesg),
-             _("Last %s or +size or +sizeM or +sizeK"),
+             "Last %s or +size or +sizeM or +sizeK",
              str_units(SINGULAR));
         stop = read_int(cround(start), cround(limit), cround(limit),
@@ -5185 +2306 @@
         pen->ext_pointer = p;
         pe4->offset = extended_offset = start;
-        pe4->sectorbuffer = xcalloc(1, sector_size);
+        pe4->sectorbuffer = xzalloc(sector_size);
         pe4->part_table = pt_offset(pe4->sectorbuffer, 0);
         pe4->ext_pointer = pe4->part_table + 1;
@@ -5199 +2320 @@
         struct pte *pe = &ptes[partitions];
 
-        pe->sectorbuffer = xcalloc(1, sector_size);
+        pe->sectorbuffer = xzalloc(sector_size);
         pe->part_table = pt_offset(pe->sectorbuffer, 0);
         pe->ext_pointer = pe->part_table + 1;
@@ -5217 +2338 @@
         return;
 
-#ifdef CONFIG_FEATURE_SUN_LABEL
-    if (label_sun == current_label_type) {
+    if (LABEL_IS_SUN) {
         add_sun_partition(get_partition(0, partitions), LINUX_NATIVE);
         return;
     }
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-    if (label_sgi == current_label_type) {
+    if (LABEL_IS_SGI) {
         sgi_add_partition(get_partition(0, partitions), LINUX_NATIVE);
         return;
     }
-#endif
-#ifdef CONFIG_FEATURE_AIX_LABEL
-    if (label_aix == current_label_type) {
-        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"));
+    if (LABEL_IS_AIX) {
+        printf("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.\n");
         return;
     }
-#endif
 
     for (i = 0; i < 4; i++)
@@ -5244 +2357 @@
 
     if (!free_primary && partitions >= MAXIMUM_PARTS) {
-        printf(_("The maximum number of partitions has been created\n"));
+        printf("The maximum number of partitions has been created\n");
         return;
     }
@@ -5252 +2365 @@
             add_logical();
         else
-            printf(_("You must delete some partition and add "
-                 "an extended partition first\n"));
+            printf("You must delete some partition and add "
+                 "an extended partition first\n");
     } 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) {
-            if ((c = read_char(line)) == 'p' || c == 'P') {
+            c = read_nonempty(line);
+            if (c == 'p' || c == 'P') {
                 i = get_nonexisting_partition(0, 4);
                 if (i >= 0)
@@ -5267 +2383 @@
                 return;
             }
-            else if (c == 'l' && extended_offset) {
+            if (c == 'l' && extended_offset) {
                 add_logical();
                 return;
             }
-            else if (c == 'e' && !extended_offset) {
+            if (c == 'e' && !extended_offset) {
                 i = get_nonexisting_partition(0, 4);
                 if (i >= 0)
@@ -5277 +2393 @@
                 return;
             }
-            else
-                printf(_("Invalid partition number "
-                     "for type `%c'\n"), c);
+            printf("Invalid partition number "
+                     "for type '%c'\n", c);
         }
     }
@@ -5289 +2404 @@
     int i;
 
-    if (label_dos == current_label_type) {
+    if (LABEL_IS_DOS) {
         for (i = 0; i < 3; i++)
             if (ptes[i].changed)
@@ -5302 +2417 @@
         }
     }
-#ifdef CONFIG_FEATURE_SGI_LABEL
-    else if (label_sgi == current_label_type) {
+    else if (LABEL_IS_SGI) {
         /* no test on change? the printf below might be mistaken */
         sgi_write_table();
     }
-#endif
-#ifdef CONFIG_FEATURE_SUN_LABEL
-    else if (label_sun == current_label_type) {
+    else if (LABEL_IS_SUN) {
         int needw = 0;
 
@@ -5318 +2430 @@
             sun_write_table();
     }
-#endif
-
-    printf(_("The partition table has been altered!\n\n"));
+
+    printf("The partition table has been altered!\n\n");
     reread_partition_table(1);
 }
@@ -5327 +2438 @@
 reread_partition_table(int leave)
 {
-    int error = 0;
     int i;
 
-    printf(_("Calling ioctl() to re-read partition table.\n"));
+    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));
-    }
-
+    /* sleep(2); Huh? */
+    i = ioctl_or_perror(fd, BLKRRPART, NULL,
+            "WARNING: rereading partition table "
+            "failed, kernel still uses old table");
+#if 0
     if (dos_changed)
         printf(
-        _("\nWARNING: If you have created or modified any DOS 6.x\n"
+        "\nWARNING: If you have created or modified any DOS 6.x\n"
         "partitions, please see the fdisk manual page for additional\n"
-        "information.\n"));
+        "information\n");
+#endif
 
     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_CLEAN_UP)
+            close(fd);
+        exit(i != 0);
+    }
+}
+#endif /* FEATURE_FDISK_WRITABLE */
+
+#if ENABLE_FEATURE_FDISK_ADVANCED
 #define MAX_PER_LINE    16
 static void
@@ -5383 +2474 @@
         printf(" %02X", (unsigned char) pbuffer[i]);
         if (l == MAX_PER_LINE - 1) {
-            printf("\n");
+            puts("");
             l = -1;
         }
     }
     if (l > 0)
-        printf("\n");
-    printf("\n");
-}
-
+        puts("");
+    puts("");
+}
 
 static void
@@ -5398 +2488 @@
     int i;
 
-    printf(_("Device: %s\n"), disk_device);
-#if defined(CONFIG_FEATURE_SGI_LABEL) || defined(CONFIG_FEATURE_SUN_LABEL)
-    if (label_sun == current_label_type || label_sgi == current_label_type)
+    printf("Device: %s\n", disk_device);
+    if (LABEL_IS_SGI || LABEL_IS_SUN)
         print_buffer(MBRbuffer);
-    else
-#endif
+    else {
         for (i = 3; i < partitions; i++)
             print_buffer(ptes[i].sectorbuffer);
+    }
 }
 
@@ -5413 +2502 @@
     struct pte *pe = &ptes[i];
     struct partition *p = pe->part_table;
-    off_t new, first;
+    ullong new, first;
 
     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);
+        printf("Partition %d has no data area\n", i + 1);
         return;
     }
     first = get_partition_start(pe);
     new = read_int(first, first, first + get_nr_sects(p) - 1, first,
-               _("New beginning of data")) - pe->offset;
+               "New beginning of data") - pe->offset;
 
     if (new != get_nr_sects(p)) {
@@ -5440 +2529 @@
     while (1) {
         putchar('\n');
-        c = tolower(read_char(_("Expert command (m for help): ")));
+        c = tolower(read_nonempty("Expert command (m for help): "));
         switch (c) {
         case 'a':
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            if (label_sun == current_label_type)
+            if (LABEL_IS_SUN)
                 sun_set_alt_cyl();
-#endif
             break;
         case 'b':
-            if (label_dos == current_label_type)
+            if (LABEL_IS_DOS)
                 move_begin(get_partition(0, partitions));
             break;
@@ -5455 +2542 @@
             user_cylinders = cylinders =
                 read_int(1, cylinders, 1048576, 0,
-                    _("Number of cylinders"));
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            if (label_sun == current_label_type)
+                    "Number of cylinders");
+            if (LABEL_IS_SUN)
                 sun_set_ncyl(cylinders);
-#endif
-            if (label_dos == current_label_type)
+            if (LABEL_IS_DOS)
                 warn_cylinders();
             break;
@@ -5467 +2552 @@
             break;
         case 'e':
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            if (label_sgi == current_label_type)
+            if (LABEL_IS_SGI)
                 sgi_set_xcyl();
-            else
-#endif
-#ifdef CONFIG_FEATURE_SUN_LABEL
-             if (label_sun == current_label_type)
+            else if (LABEL_IS_SUN)
                 sun_set_xcyl();
-             else
-#endif
-            if (label_dos == current_label_type)
+            else if (LABEL_IS_DOS)
                 x_list_table(1);
             break;
         case 'f':
-            if (label_dos == current_label_type)
+            if (LABEL_IS_DOS)
                 fix_partition_table_order();
             break;
         case 'g':
-#ifdef CONFIG_FEATURE_SGI_LABEL
+#if ENABLE_FEATURE_SGI_LABEL
             create_sgilabel();
 #endif
@@ -5491 +2570 @@
         case 'h':
             user_heads = heads = read_int(1, heads, 256, 0,
-                    _("Number of heads"));
+                    "Number of heads");
             update_units();
             break;
         case 'i':
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            if (label_sun == current_label_type)
+            if (LABEL_IS_SUN)
                 sun_set_ilfact();
-#endif
             break;
         case 'o':
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            if (label_sun == current_label_type)
+            if (LABEL_IS_SUN)
                 sun_set_rspeed();
-#endif
             break;
         case 'p':
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            if (label_sun == current_label_type)
+            if (LABEL_IS_SUN)
                 list_table(1);
             else
-#endif
                 x_list_table(0);
             break;
         case 'q':
             close(fd);
-            printf("\n");
+            puts("");
             exit(0);
         case 'r':
@@ -5522 +2595 @@
         case 's':
             user_sectors = sectors = read_int(1, sectors, 63, 0,
-                       _("Number of sectors"));
+                       "Number of sectors");
             if (dos_compatible_flag) {
                 sector_offset = sectors;
-                fprintf(stderr, _("Warning: setting "
-                    "sector offset for DOS "
-                    "compatiblity\n"));
+                printf("Warning: setting sector offset for DOS "
+                    "compatiblity\n");
             }
             update_units();
@@ -5538 +2610 @@
             break;
         case 'y':
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            if (label_sun == current_label_type)
+            if (LABEL_IS_SUN)
                 sun_set_pcylcount();
-#endif
             break;
         default:
@@ -5586 +2656 @@
 
 static void
-try(const char *device, int user_specified)
+trydev(const char *device, int user_specified)
 {
     int gb;
@@ -5596 +2666 @@
         if (is_ide_cdrom_or_tape(device))
             return;
-    if ((fd = open(disk_device, type_open)) >= 0) {
+    fd = open(disk_device, type_open);
+    if (fd >= 0) {
         gb = get_boot(try_only);
         if (gb > 0) {   /* I/O error */
@@ -5602 +2673 @@
         } else if (gb < 0) { /* no DOS signature */
             list_disk_geometry();
-            if (label_aix == current_label_type){
+            if (LABEL_IS_AIX) {
                 return;
             }
-#ifdef CONFIG_FEATURE_OSF_LABEL
-            if (btrydev(device) < 0)
-#endif
-                fprintf(stderr,
-                    _("Disk %s doesn't contain a valid "
-                    "partition table\n"), device);
+#if ENABLE_FEATURE_OSF_LABEL
+            if (bsd_trydev(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_sun != current_label_type && partitions > 4){
+#if ENABLE_FEATURE_FDISK_WRITABLE
+            if (!LABEL_IS_SUN && partitions > 4){
                 delete_partition(ext_index);
             }
@@ -5626 +2696 @@
            installed on the system. */
         if (errno == EACCES) {
-            fprintf(stderr, _("Cannot open %s\n"), device);
+            printf("Cannot open %s\n", device);
             return;
         }
@@ -5641 +2711 @@
     int ma, mi, sz;
 
-    procpt = bb_wfopen(PROC_PARTITIONS, "r");
+    procpt = fopen_or_warn("/proc/partitions", "r");
 
     while (fgets(line, sizeof(line), procpt)) {
@@ -5651 +2721 @@
             continue;
         sprintf(devname, "/dev/%s", ptname);
-        try(devname, 0);
-    }
-#ifdef CONFIG_FEATURE_CLEAN_UP
+        trydev(devname, 0);
+    }
+#if ENABLE_FEATURE_CLEAN_UP
     fclose(procpt);
 #endif
 }
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
+#if ENABLE_FEATURE_FDISK_WRITABLE
 static void
 unknown_command(int c)
 {
-    printf(_("%c: unknown command\n"), c);
-}
-#endif
-
+    printf("%c: unknown command\n", c);
+}
+#endif
+
+int fdisk_main(int argc, char **argv);
 int fdisk_main(int argc, char **argv)
 {
-    int c;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-    int optl = 0;
-#endif
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
-    int opts = 0;
-#endif
+    char *str_b, *str_C, *str_H, *str_S;
+    unsigned opt;
     /*
-     * Calls:
      *  fdisk -v
      *  fdisk -l [-b sectorsize] [-u] device ...
@@ -5683 +2748 @@
      *
      * Options -C, -H, -S set the geometry.
-     *
      */
-    while ((c = getopt(argc, argv, "b:C:H:lS:uvV"
-#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 = atoi(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 = atoi(optarg);
-            break;
-        case 'H':
-            user_heads = atoi(optarg);
-            if (user_heads <= 0 || user_heads >= 256)
-                user_heads = 0;
-            break;
-        case 'S':
-            user_sectors = atoi(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;
-        case 'V':
-        case 'v':
-            printf("fdisk v" UTIL_LINUX_VERSION "\n");
-            return 0;
-        default:
+    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,
+    };
+
+    PTR_TO_GLOBALS = xzalloc(sizeof(G));
+
+    opt = getopt32(argv, "b:C:H:lS:u" USE_FEATURE_FDISK_BLKSIZE("s"),
+                &str_b, &str_C, &str_H, &str_S);
+    argc -= optind;
+    argv += optind;
+    if (opt & OPT_b) { // -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.
+        */
+        sector_size = xatoi_u(str_b);
+        if (sector_size != 512 && sector_size != 1024 &&
+            sector_size != 2048)
             bb_show_usage();
-        }
-    }
-
-#if 0
-    printf(_("This kernel finds the sector size itself - "
-         "-b option ignored\n"));
-#else
-    if (user_set_sector_size && argc-optind != 1)
-        printf(_("Warning: the -b (set sector size) option should"
-             " be used with one specified device\n"));
-#endif
-
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-    if (optl) {
+        sector_offset = 2;
+        user_set_sector_size = 1;
+    }
+    if (opt & OPT_C) user_cylinders = xatoi_u(str_C); // -C
+    if (opt & OPT_H) { // -H
+        user_heads = xatoi_u(str_H);
+        if (user_heads <= 0 || user_heads >= 256)
+            user_heads = 0;
+    }
+    //if (opt & OPT_l) // -l
+    if (opt & OPT_S) { // -S
+        user_sectors = xatoi_u(str_S);
+        if (user_sectors <= 0 || user_sectors >= 64)
+            user_sectors = 0;
+    }
+    if (opt & OPT_u) display_in_cyl_units = 0; // -u
+    //if (opt & OPT_s) // -s
+
+    if (user_set_sector_size && argc != 1)
+        printf("Warning: the -b (set sector size) option should"
+             " be used with one specified device\n");
+
+#if ENABLE_FEATURE_FDISK_WRITABLE
+    if (opt & OPT_l) {
         nowarn = 1;
 #endif
         type_open = O_RDONLY;
-        if (argc > optind) {
+        if (argc > 0) {
             int k;
-#if __GNUC__
+#if defined(__GNUC__)
             /* avoid gcc warning:
                variable `k' might be clobbered by `longjmp' */
@@ -5760 +2809 @@
 #endif
             listing = 1;
-            for (k = optind; k < argc; k++)
-                try(argv[k], 1);
+            for (k = 0; k < argc; k++)
+                trydev(argv[k], 1);
         } else {
             /* we no longer have default device names */
@@ -5768 +2817 @@
         }
         return 0;
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-    }
-#endif
-
-#ifdef CONFIG_FEATURE_FDISK_BLKSIZE
-    if (opts) {
+#if ENABLE_FEATURE_FDISK_WRITABLE
+    }
+#endif
+
+#if ENABLE_FEATURE_FDISK_BLKSIZE
+    if (opt & OPT_s) {
         long size;
         int j;
@@ -5780 +2829 @@
         type_open = O_RDONLY;
 
-        opts = argc - optind;
-        if (opts <= 0)
+        if (argc <= 0)
             bb_show_usage();
 
-        for (j = optind; j < argc; j++) {
+        for (j = 0; j < argc; j++) {
             disk_device = argv[j];
-            if ((fd = open(disk_device, type_open)) < 0)
+            fd = open(disk_device, type_open);
+            if (fd < 0)
                 fdisk_fatal(unable_to_open);
             if (ioctl(fd, BLKGETSIZE, &size))
                 fdisk_fatal(ioctl_error);
             close(fd);
-            if (opts == 1)
+            if (argc == 1)
                 printf("%ld\n", size/2);
             else
@@ -5800 +2849 @@
 #endif
 
-#ifdef CONFIG_FEATURE_FDISK_WRITABLE
-    if (argc-optind == 1)
-        disk_device = argv[optind];
-    else
+#if ENABLE_FEATURE_FDISK_WRITABLE
+    if (argc != 1)
         bb_show_usage();
 
+    disk_device = argv[0];
     get_boot(fdisk);
 
-#ifdef CONFIG_FEATURE_OSF_LABEL
-    if (label_osf == current_label_type) {
+    if (LABEL_IS_OSF) {
         /* OSF label, and no DOS label */
-        printf(_("Detected an OSF/1 disklabel on %s, entering "
-             "disklabel mode.\n"),
-               disk_device);
-        bselect();
+        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*/
         current_label_type = label_dos;
         /* If we return we may want to make an empty DOS label? */
     }
-#endif
 
     while (1) {
+        int c;
         putchar('\n');
-        c = tolower(read_char(_("Command (m for help): ")));
+        c = tolower(read_nonempty("Command (m for help): "));
         switch (c) {
         case 'a':
-            if (label_dos == current_label_type)
+            if (LABEL_IS_DOS)
                 toggle_active(get_partition(1, partitions));
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            else if (label_sun == current_label_type)
+            else if (LABEL_IS_SUN)
                 toggle_sunflags(get_partition(1, partitions),
                         0x01);
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            else if (label_sgi == current_label_type)
+            else if (LABEL_IS_SGI)
                 sgi_set_bootpartition(
                     get_partition(1, partitions));
-#endif
             else
                 unknown_command(c);
             break;
         case 'b':
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            if (label_sgi == current_label_type) {
-                printf(_("\nThe current boot file is: %s\n"),
+            if (LABEL_IS_SGI) {
+                printf("\nThe current boot file is: %s\n",
                     sgi_get_bootfile());
-                if (read_chars(_("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')
+                    printf("Boot file unchanged\n");
                 else
                     sgi_set_bootfile(line_ptr);
-            } else
-#endif
-#ifdef CONFIG_FEATURE_OSF_LABEL
-                bselect();
+            }
+#if ENABLE_FEATURE_OSF_LABEL
+            else
+                bsd_select();
 #endif
             break;
         case 'c':
-            if (label_dos == current_label_type)
+            if (LABEL_IS_DOS)
                 toggle_dos_compatibility_flag();
-#ifdef CONFIG_FEATURE_SUN_LABEL
-            else if (label_sun == current_label_type)
+            else if (LABEL_IS_SUN)
                 toggle_sunflags(get_partition(1, partitions),
                         0x10);
-#endif
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            else if (label_sgi == current_label_type)
+            else if (LABEL_IS_SGI)
                 sgi_set_swappartition(
                         get_partition(1, partitions));
-#endif
             else
                 unknown_command(c);
@@ -5876 +2913 @@
             {
                 int j;
-#ifdef CONFIG_FEATURE_SGI_LABEL
             /* If sgi_label then don't use get_existing_partition,
                let the user select a partition, since
                get_existing_partition() only works for Linux-like
                partition tables */
-                if (label_sgi != current_label_type) {
+                if (!LABEL_IS_SGI) {
                     j = get_existing_partition(1, partitions);
                 } else {
                     j = get_partition(1, partitions);
                 }
-#else
-                j = get_existing_partition(1, partitions);
-#endif
                 if (j >= 0)
                     delete_partition(j);
@@ -5894 +2927 @@
             break;
         case 'i':
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            if (label_sgi == current_label_type)
+            if (LABEL_IS_SGI)
                 create_sgiinfo();
             else
-#endif
                 unknown_command(c);
         case 'l':
@@ -5917 +2948 @@
         case 'q':
             close(fd);
-            printf("\n");
+            puts("");
             return 0;
         case 's':
-#ifdef CONFIG_FEATURE_SUN_LABEL
+#if ENABLE_FEATURE_SUN_LABEL
             create_sunlabel();
 #endif
@@ -5936 +2967 @@
             write_table();          /* does not return */
             break;
-#ifdef CONFIG_FEATURE_FDISK_ADVANCED
+#if ENABLE_FEATURE_FDISK_ADVANCED
         case 'x':
-#ifdef CONFIG_FEATURE_SGI_LABEL
-            if (label_sgi == current_label_type) {
-                fprintf(stderr,
-                    _("\n\tSorry, no experts menu for SGI "
-                    "partition tables available.\n\n"));
+            if (LABEL_IS_SGI) {
+                printf("\n\tSorry, no experts menu for SGI "
+                    "partition tables available\n\n");
             } else
-#endif
-
                 xselect();
             break;
@@ -5955 +2982 @@
     }
     return 0;
-#endif /* CONFIG_FEATURE_FDISK_WRITABLE */
-}
+#endif /* FEATURE_FDISK_WRITABLE */
+}

branches/2.2.5/mindi-busybox/util-linux/freeramdisk.c

@@ -7 +7 @@
  * Unified with fdflush by Tito Ragusa <farmatito@tiscali.it>
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2, see file LICENSE in this tarball for details.
  */
 
-#include <stdio.h>
-#include <string.h>
-#include <sys/types.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include "busybox.h"
+#include "libbb.h"
 
 /* From <linux/fd.h> */
 #define FDFLUSH  _IO(2,0x4b)
 
+int freeramdisk_main(int argc, char **argv);
 int freeramdisk_main(int argc, char **argv)
 {
-    int result;
     int fd;
 
     if (argc != 2) bb_show_usage();
 
-    fd = bb_xopen(argv[1], O_RDWR);
+    fd = xopen(argv[1], O_RDWR);
 
     // Act like freeramdisk, fdflush, or both depending on configuration.
-    result = ioctl(fd, (ENABLE_FREERAMDISK && bb_applet_name[1]=='r')
-            || !ENABLE_FDFLUSH ? BLKFLSBUF : FDFLUSH);
+    ioctl_or_perror_and_die(fd, (ENABLE_FREERAMDISK && applet_name[1]=='r')
+            || !ENABLE_FDFLUSH ? BLKFLSBUF : FDFLUSH, NULL, "%s", argv[1]);
 
     if (ENABLE_FEATURE_CLEAN_UP) close(fd);
 
-    if (result) bb_perror_msg_and_die("%s", argv[1]);
     return EXIT_SUCCESS;
 }

branches/2.2.5/mindi-busybox/util-linux/fsck_minix.c

@@ -3 +3 @@
  * fsck.c - a file system consistency checker for Linux.
  *
- * (C) 1991, 1992 Linus Torvalds. This file may be redistributed
- * as per the GNU copyleft.
+ * (C) 1991, 1992 Linus Torvalds.
+ *
+ * Licensed under GPLv2, see file LICENSE in this tarball for details.
  */
 
@@ -87 +88 @@
  */
 
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <termios.h>
 #include <mntent.h>
-#include <sys/param.h>
-#include "busybox.h"
-
-/*
- * This is the original minix inode layout on disk.
- * Note the 8-bit gid and atime and ctime.
- */
-struct minix_inode {
-    uint16_t i_mode;
-    uint16_t i_uid;
-    uint32_t i_size;
-    uint32_t i_time;
-    uint8_t  i_gid;
-    uint8_t  i_nlinks;
-    uint16_t i_zone[9];
-};
-
-/*
- * The new minix inode has all the time entries, as well as
- * long block numbers and a third indirect block (7+1+1+1
- * instead of 7+1+1). Also, some previously 8-bit values are
- * now 16-bit. The inode is now 64 bytes instead of 32.
- */
-struct minix2_inode {
-    uint16_t i_mode;
-    uint16_t i_nlinks;
-    uint16_t i_uid;
-    uint16_t i_gid;
-    uint32_t i_size;
-    uint32_t i_atime;
-    uint32_t i_mtime;
-    uint32_t i_ctime;
-    uint32_t i_zone[10];
-};
+#include "libbb.h"
+#include "minix.h"
+
+#ifndef BLKGETSIZE
+#define BLKGETSIZE _IO(0x12,96)    /* return device size */
+#endif
 
 enum {
-    MINIX_ROOT_INO = 1,
-    MINIX_LINK_MAX = 250,
+#ifdef UNUSED
+    MINIX1_LINK_MAX = 250,
     MINIX2_LINK_MAX = 65530,
-
     MINIX_I_MAP_SLOTS = 8,
     MINIX_Z_MAP_SLOTS = 64,
-    MINIX_SUPER_MAGIC = 0x137F,     /* original minix fs */
-    MINIX_SUPER_MAGIC2 = 0x138F,        /* minix fs, 30 char names */
-    MINIX2_SUPER_MAGIC = 0x2468,        /* minix V2 fs */
-    MINIX2_SUPER_MAGIC2 = 0x2478,       /* minix V2 fs, 30 char names */
-    MINIX_VALID_FS = 0x0001,        /* Clean fs. */
-    MINIX_ERROR_FS = 0x0002,        /* fs has errors. */
-
-    MINIX_INODES_PER_BLOCK = ((BLOCK_SIZE)/(sizeof (struct minix_inode))),
-    MINIX2_INODES_PER_BLOCK = ((BLOCK_SIZE)/(sizeof (struct minix2_inode))),
-
-    MINIX_V1 = 0x0001,      /* original minix fs */
-    MINIX_V2 = 0x0002       /* minix V2 fs */
+    MINIX_V1 = 0x0001,      /* original minix fs */
+    MINIX_V2 = 0x0002,      /* minix V2 fs */
+#endif
+    MINIX_NAME_MAX = 255,         /* # chars in a file name */
 };
 
-#define INODE_VERSION(inode)    inode->i_sb->u.minix_sb.s_version
-
-/*
- * minix super-block data on disk
- */
-struct minix_super_block {
-    uint16_t s_ninodes;
-    uint16_t s_nzones;
-    uint16_t s_imap_blocks;
-    uint16_t s_zmap_blocks;
-    uint16_t s_firstdatazone;
-    uint16_t s_log_zone_size;
-    uint32_t s_max_size;
-    uint16_t s_magic;
-    uint16_t s_state;
-    uint32_t s_zones;
+#if !ENABLE_FEATURE_MINIX2
+enum { version2 = 0 };
+#endif
+
+enum { MAX_DEPTH = 32 };
+
+struct globals {
+    int dev_fd;
+#if ENABLE_FEATURE_MINIX2
+    smallint version2;
+#endif
+    smallint repair, automatic, verbose, list, show, warn_mode, force;
+    smallint changed;  /* is filesystem modified? */
+    smallint errors_uncorrected;  /* flag if some error was not corrected */
+    smallint termios_set;
+    smallint dirsize;
+    smallint namelen;
+    char *device_name;
+    int directory, regular, blockdev, chardev, links, symlinks, total;
+    char *inode_buffer;
+
+    char *inode_map;
+    char *zone_map;
+
+    unsigned char *inode_count;
+    unsigned char *zone_count;
+
+    /* File-name data */
+    int name_depth;
+    char *name_component[MAX_DEPTH+1];
+
+    /* Bigger stuff */
+    struct termios sv_termios;
+    char super_block_buffer[BLOCK_SIZE];
+    char add_zone_ind_blk[BLOCK_SIZE];
+    char add_zone_dind_blk[BLOCK_SIZE];
+    USE_FEATURE_MINIX2(char add_zone_tind_blk[BLOCK_SIZE];)
+    char check_file_blk[BLOCK_SIZE];
+
+    /* File-name data */
+    char current_name[MAX_DEPTH * MINIX_NAME_MAX];
 };
 
-struct minix_dir_entry {
-    uint16_t inode;
-    char name[0];
-};
-
-
-#define NAME_MAX         255   /* # chars in a file name */
-
-#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
-
-#ifndef BLKGETSIZE
-#define BLKGETSIZE _IO(0x12,96)    /* return device size */
-#endif
-
-#ifndef __linux__
-#define volatile
-#endif
-
-enum { ROOT_INO = 1 };
-
-#define UPPER(size,n) ((size+((n)-1))/(n))
-#define INODE_SIZE (sizeof(struct minix_inode))
-#ifdef CONFIG_FEATURE_MINIX2
-#define INODE_SIZE2 (sizeof(struct minix2_inode))
-#define INODE_BLOCKS UPPER(INODES, (version2 ? MINIX2_INODES_PER_BLOCK \
-                    : MINIX_INODES_PER_BLOCK))
+#define G (*ptr_to_globals)
+#define dev_fd             (G.dev_fd             )
+#if ENABLE_FEATURE_MINIX2
+#define version2           (G.version2           )
+#endif
+#define repair             (G.repair             )
+#define automatic          (G.automatic          )
+#define verbose            (G.verbose            )
+#define list               (G.list               )
+#define show               (G.show               )
+#define warn_mode          (G.warn_mode          )
+#define force              (G.force              )
+#define changed            (G.changed            )
+#define errors_uncorrected (G.errors_uncorrected )
+#define termios_set        (G.termios_set        )
+#define dirsize            (G.dirsize            )
+#define namelen            (G.namelen            )
+#define device_name        (G.device_name        )
+#define directory          (G.directory          )
+#define regular            (G.regular            )
+#define blockdev           (G.blockdev           )
+#define chardev            (G.chardev            )
+#define links              (G.links              )
+#define symlinks           (G.symlinks           )
+#define total              (G.total              )
+#define inode_buffer       (G.inode_buffer       )
+#define inode_map          (G.inode_map          )
+#define zone_map           (G.zone_map           )
+#define inode_count        (G.inode_count        )
+#define zone_count         (G.zone_count         )
+#define name_depth         (G.name_depth         )
+#define name_component     (G.name_component     )
+#define sv_termios         (G.sv_termios         )
+#define super_block_buffer (G.super_block_buffer )
+#define add_zone_ind_blk   (G.add_zone_ind_blk   )
+#define add_zone_dind_blk  (G.add_zone_dind_blk  )
+#define add_zone_tind_blk  (G.add_zone_tind_blk  )
+#define check_file_blk     (G.check_file_blk     )
+#define current_name       (G.current_name       )
+#define INIT_G() do { \
+    PTR_TO_GLOBALS = xzalloc(sizeof(G)); \
+    dirsize = 16; \
+    namelen = 14; \
+    current_name[0] = '/'; \
+    /*current_name[1] = '\0';*/ \
+    name_component[0] = &current_name[0]; \
+} while (0)
+
+#define Inode1 (((struct minix1_inode *) inode_buffer)-1)
+#define Inode2 (((struct minix2_inode *) inode_buffer)-1)
+
+#define Super (*(struct minix_super_block *)(super_block_buffer))
+
+#if ENABLE_FEATURE_MINIX2
+# define ZONES    ((unsigned)(version2 ? Super.s_zones : Super.s_nzones))
 #else
-#define INODE_BLOCKS UPPER(INODES, (MINIX_INODES_PER_BLOCK))
-#endif
+# define ZONES    ((unsigned)(Super.s_nzones))
+#endif
+#define INODES    ((unsigned)Super.s_ninodes)
+#define IMAPS     ((unsigned)Super.s_imap_blocks)
+#define ZMAPS     ((unsigned)Super.s_zmap_blocks)
+#define FIRSTZONE ((unsigned)Super.s_firstdatazone)
+#define ZONESIZE  ((unsigned)Super.s_log_zone_size)
+#define MAXSIZE   ((unsigned)Super.s_max_size)
+#define MAGIC     (Super.s_magic)
+
+/* gcc likes this more (code is smaller) than macro variant */
+static ALWAYS_INLINE unsigned div_roundup(unsigned size, unsigned n)
+{
+    return (size + n-1) / n;
+}
+
+#if ENABLE_FEATURE_MINIX2
+#define INODE_BLOCKS div_roundup(INODES, (version2 ? MINIX2_INODES_PER_BLOCK \
+                    : MINIX1_INODES_PER_BLOCK))
+#else
+#define INODE_BLOCKS div_roundup(INODES, MINIX1_INODES_PER_BLOCK)
+#endif
+
 #define INODE_BUFFER_SIZE (INODE_BLOCKS * BLOCK_SIZE)
-
-#define BITS_PER_BLOCK (BLOCK_SIZE<<3)
-
-static char *program_version = "1.2 - 11/11/96";
-static char *device_name;
-static int IN;
-static int repair, automatic, verbose, list, show, warn_mode, force;
-static int directory, regular, blockdev, chardev, links, symlinks, total;
-
-static int changed;         /* flags if the filesystem has been changed */
-static int errors_uncorrected;  /* flag if some error was not corrected */
-static int dirsize = 16;
-static int namelen = 14;
-static struct termios termios;
-static int termios_set;
-
-static char *inode_buffer;
-#define Inode (((struct minix_inode *) inode_buffer)-1)
-#define Inode2 (((struct minix2_inode *) inode_buffer)-1)
-static char super_block_buffer[BLOCK_SIZE];
-
-#define Super (*(struct minix_super_block *)super_block_buffer)
-#define INODES ((unsigned long)Super.s_ninodes)
-#ifdef CONFIG_FEATURE_MINIX2
-static int version2;
-#define ZONES ((unsigned long)(version2 ? Super.s_zones : Super.s_nzones))
-#else
-#define ZONES ((unsigned long)(Super.s_nzones))
-#endif
-#define IMAPS ((unsigned long)Super.s_imap_blocks)
-#define ZMAPS ((unsigned long)Super.s_zmap_blocks)
-#define FIRSTZONE ((unsigned long)Super.s_firstdatazone)
-#define ZONESIZE ((unsigned long)Super.s_log_zone_size)
-#define MAXSIZE ((unsigned long)Super.s_max_size)
-#define MAGIC (Super.s_magic)
-#define NORM_FIRSTZONE (2+IMAPS+ZMAPS+INODE_BLOCKS)
-
-static char *inode_map;
-static char *zone_map;
-
-static unsigned char *inode_count;
-static unsigned char *zone_count;
-
-static void recursive_check(unsigned int ino);
-#ifdef CONFIG_FEATURE_MINIX2
-static void recursive_check2(unsigned int ino);
-#endif
-
-static inline int bit(char *a, unsigned int i)
-{
-      return (a[i >> 3] & (1<<(i & 7))) != 0;
-}
-#define inode_in_use(x) (bit(inode_map,(x)))
-#define zone_in_use(x) (bit(zone_map,(x)-FIRSTZONE+1))
-
-#define mark_inode(x) (setbit(inode_map,(x)),changed=1)
-#define unmark_inode(x) (clrbit(inode_map,(x)),changed=1)
-
-#define mark_zone(x) (setbit(zone_map,(x)-FIRSTZONE+1),changed=1)
-#define unmark_zone(x) (clrbit(zone_map,(x)-FIRSTZONE+1),changed=1)
-
-static void leave(int) ATTRIBUTE_NORETURN;
-static void leave(int status)
+#define NORM_FIRSTZONE    (2 + IMAPS + ZMAPS + INODE_BLOCKS)
+
+/* Before you ask "where they come from?": */
+/* setbit/clrbit are supplied by sys/param.h */
+
+static int minix_bit(const char *a, unsigned i)
+{
+    return (a[i >> 3] & (1<<(i & 7)));
+}
+
+static void minix_setbit(char *a, unsigned i)
+{
+    setbit(a, i);
+    changed = 1;
+}
+static void minix_clrbit(char *a, unsigned i)
+{
+    clrbit(a, i);
+    changed = 1;
+}
+
+/* Note: do not assume 0/1, it is 0/nonzero */
+#define zone_in_use(x)  (minix_bit(zone_map,(x)-FIRSTZONE+1))
+#define inode_in_use(x) (minix_bit(inode_map,(x)))
+
+#define mark_inode(x)   (minix_setbit(inode_map,(x)))
+#define unmark_inode(x) (minix_clrbit(inode_map,(x)))
+
+#define mark_zone(x)    (minix_setbit(zone_map,(x)-FIRSTZONE+1))
+#define unmark_zone(x)  (minix_clrbit(zone_map,(x)-FIRSTZONE+1))
+
+
+static void recursive_check(unsigned ino);
+#if ENABLE_FEATURE_MINIX2
+static void recursive_check2(unsigned ino);
+#endif
+
+static void die(const char *str) ATTRIBUTE_NORETURN;
+static void die(const char *str)
 {
     if (termios_set)
-        tcsetattr(0, TCSANOW, &termios);
-    exit(status);
-}
-
-static void die(const char *str)
-{
-    bb_error_msg("%s", str);
-    leave(8);
-}
-
-/* File-name data */
-enum { MAX_DEPTH = 32 };
-static int name_depth;
-static char *current_name;
-static char *name_component[MAX_DEPTH+1];
-
-/* Wed Feb  9 15:17:06 MST 2000 */
-/* dynamically allocate name_list (instead of making it static) */
-static inline void alloc_current_name(void)
-{
-    current_name = xmalloc(MAX_DEPTH * (BUFSIZ + 1));
-    current_name[0] = '/';
-    current_name[1] = '\0';
-    name_component[0] = &current_name[0];
-}
-
-#ifdef CONFIG_FEATURE_CLEAN_UP
-/* execute this atexit() to deallocate name_list[] */
-/* piptigger was here */
-static inline void free_current_name(void)
-{
-    free(current_name);
-}
-#endif
+        tcsetattr(0, TCSANOW, &sv_termios);
+    bb_error_msg_and_die("%s", str);
+}
 
 static void push_filename(const char *name)
@@ -315 +291 @@
 }
 
-static void pop_filename(void) {
+static void pop_filename(void)
+{
     name_depth--;
     if (name_depth < MAX_DEPTH) {
@@ -331 +308 @@
 
     if (!repair) {
-        printf("\n");
+        puts("");
         errors_uncorrected = 1;
         return 0;
     }
     if (automatic) {
-        printf("\n");
+        puts("");
         if (!def)
             errors_uncorrected = 1;
@@ -344 +321 @@
     for (;;) {
         fflush(stdout);
-        if ((c = getchar()) == EOF) {
+        c = getchar();
+        if (c == EOF) {
             if (!def)
                 errors_uncorrected = 1;
@@ -380 +358 @@
     int fd;
 
-    if ((f = setmntent(MOUNTED, "r")) == NULL)
+    f = setmntent(MOUNTED, "r");
+    if (f == NULL)
         return;
     while ((mnt = getmntent(f)) != NULL)
@@ -397 +376 @@
     if (fd < 0 && errno == EROFS)
         return;
-    else
-        close(fd);
+    close(fd);
 
     printf("%s is mounted. ", device_name);
@@ -408 +386 @@
         exit(0);
     }
-    return;
 }
 
@@ -417 +394 @@
  * or a bad zone-number).
  */
-static int check_zone_nr2(uint32_t *nr, int *corrected)
+static int check_zone_nr2(uint32_t *nr, smallint *corrected)
 {
     const char *msg;
@@ -436 +413 @@
 }
 
-static int check_zone_nr(uint16_t *nr, int *corrected)
+static int check_zone_nr(uint16_t *nr, smallint *corrected)
 {
     uint32_t nr32 = *nr;
@@ -447 +424 @@
  * read-block reads block nr into the buffer at addr.
  */
-static void read_block(unsigned int nr, char *addr)
+static void read_block(unsigned nr, char *addr)
 {
     if (!nr) {
@@ -453 +430 @@
         return;
     }
-    if (BLOCK_SIZE * nr != lseek(IN, BLOCK_SIZE * nr, SEEK_SET)) {
-        printf("%s: unable to seek to block in file '%s'\n",
+    if (BLOCK_SIZE * nr != lseek(dev_fd, BLOCK_SIZE * nr, SEEK_SET)) {
+        printf("%s: cannot seek to block in file '%s'\n",
                 bb_msg_read_error, current_name);
         errors_uncorrected = 1;
         memset(addr, 0, BLOCK_SIZE);
-    } else if (BLOCK_SIZE != read(IN, addr, BLOCK_SIZE)) {
+    } else if (BLOCK_SIZE != read(dev_fd, addr, BLOCK_SIZE)) {
         printf("%s: bad block in file '%s'\n",
                 bb_msg_read_error, current_name);
@@ -469 +446 @@
  * write_block writes block nr to disk.
  */
-static void write_block(unsigned int nr, char *addr)
+static void write_block(unsigned nr, char *addr)
 {
     if (!nr)
@@ -479 +456 @@
         return;
     }
-    if (BLOCK_SIZE * nr != lseek(IN, BLOCK_SIZE * nr, SEEK_SET))
-        die("Seek failed in write_block");
-    if (BLOCK_SIZE != write(IN, addr, BLOCK_SIZE)) {
+    if (BLOCK_SIZE * nr != lseek(dev_fd, BLOCK_SIZE * nr, SEEK_SET))
+        die("seek failed in write_block");
+    if (BLOCK_SIZE != write(dev_fd, addr, BLOCK_SIZE)) {
         printf("%s: bad block in file '%s'\n",
                 bb_msg_write_error, current_name);
@@ -493 +470 @@
  * any indirect blocks with errors.
  */
-static int map_block(struct minix_inode *inode, unsigned int blknr)
+static int map_block(struct minix1_inode *inode, unsigned blknr)
 {
     uint16_t ind[BLOCK_SIZE >> 1];
     uint16_t dind[BLOCK_SIZE >> 1];
-    int blk_chg, block, result;
+    int block, result;
+    smallint blk_chg;
 
     if (blknr < 7)
@@ -527 +505 @@
 }
 
-#ifdef CONFIG_FEATURE_MINIX2
-static int map_block2(struct minix2_inode *inode, unsigned int blknr)
+#if ENABLE_FEATURE_MINIX2
+static int map_block2(struct minix2_inode *inode, unsigned blknr)
 {
     uint32_t ind[BLOCK_SIZE >> 2];
     uint32_t dind[BLOCK_SIZE >> 2];
     uint32_t tind[BLOCK_SIZE >> 2];
-    int blk_chg, block, result;
+    int block, result;
+    smallint blk_chg;
 
     if (blknr < 7)
@@ -593 +572 @@
      * unconditionally set if we get this far.
      */
-    Super.s_state |= MINIX_VALID_FS;
-    if (errors_uncorrected)
-        Super.s_state |= MINIX_ERROR_FS;
-    else
+    Super.s_state |= MINIX_VALID_FS | MINIX_ERROR_FS;
+    if (!errors_uncorrected)
         Super.s_state &= ~MINIX_ERROR_FS;
 
-    if (BLOCK_SIZE != lseek(IN, BLOCK_SIZE, SEEK_SET))
-        die("Seek failed in write_super_block");
-    if (BLOCK_SIZE != write(IN, super_block_buffer, BLOCK_SIZE))
-        die("Unable to write super-block");
+    if (BLOCK_SIZE != lseek(dev_fd, BLOCK_SIZE, SEEK_SET))
+        die("seek failed in write_super_block");
+    if (BLOCK_SIZE != write(dev_fd, super_block_buffer, BLOCK_SIZE))
+        die("cannot write super-block");
 }
 
@@ -609 +586 @@
     write_super_block();
 
-    if (IMAPS * BLOCK_SIZE != write(IN, inode_map, IMAPS * BLOCK_SIZE))
-        die("Unable to write inode map");
-    if (ZMAPS * BLOCK_SIZE != write(IN, zone_map, ZMAPS * BLOCK_SIZE))
-        die("Unable to write zone map");
-    if (INODE_BUFFER_SIZE != write(IN, inode_buffer, INODE_BUFFER_SIZE))
-        die("Unable to write inodes");
+    if (IMAPS * BLOCK_SIZE != write(dev_fd, inode_map, IMAPS * BLOCK_SIZE))
+        die("cannot write inode map");
+    if (ZMAPS * BLOCK_SIZE != write(dev_fd, zone_map, ZMAPS * BLOCK_SIZE))
+        die("cannot write zone map");
+    if (INODE_BUFFER_SIZE != write(dev_fd, inode_buffer, INODE_BUFFER_SIZE))
+        die("cannot write inodes");
 }
 
@@ -623 +600 @@
     int size;
 
-#ifdef CONFIG_FEATURE_MINIX2
+#if ENABLE_FEATURE_MINIX2
     if (version2)
-        block = Inode2[ROOT_INO].i_zone[0];
+        block = Inode2[MINIX_ROOT_INO].i_zone[0];
     else
 #endif
-        block = Inode[ROOT_INO].i_zone[0];
+        block = Inode1[MINIX_ROOT_INO].i_zone[0];
     read_block(block, blk);
     for (size = 16; size < BLOCK_SIZE; size <<= 1) {
@@ -642 +619 @@
 static void read_superblock(void)
 {
-    if (BLOCK_SIZE != lseek(IN, BLOCK_SIZE, SEEK_SET))
-        die("Seek failed");
-    if (BLOCK_SIZE != read(IN, super_block_buffer, BLOCK_SIZE))
-        die("Unable to read super block");
+    if (BLOCK_SIZE != lseek(dev_fd, BLOCK_SIZE, SEEK_SET))
+        die("seek failed");
+    if (BLOCK_SIZE != read(dev_fd, super_block_buffer, BLOCK_SIZE))
+        die("cannot read super block");
     /* already initialized to:
     namelen = 14;
@@ -651 +628 @@
     version2 = 0;
     */
-    if (MAGIC == MINIX_SUPER_MAGIC) {
-    } else if (MAGIC == MINIX_SUPER_MAGIC2) {
+    if (MAGIC == MINIX1_SUPER_MAGIC) {
+    } else if (MAGIC == MINIX1_SUPER_MAGIC2) {
         namelen = 30;
         dirsize = 32;
-#ifdef CONFIG_FEATURE_MINIX2
+#if ENABLE_FEATURE_MINIX2
     } else if (MAGIC == MINIX2_SUPER_MAGIC) {
         version2 = 1;
@@ -664 +641 @@
 #endif
     } else
-        die("Bad magic number in super-block");
+        die("bad magic number in super-block");
     if (ZONESIZE != 0 || BLOCK_SIZE != 1024)
-        die("Only 1k blocks/zones supported");
+        die("only 1k blocks/zones supported");
     if (IMAPS * BLOCK_SIZE * 8 < INODES + 1)
-        die("Bad s_imap_blocks field in super-block");
+        die("bad s_imap_blocks field in super-block");
     if (ZMAPS * BLOCK_SIZE * 8 < ZONES - FIRSTZONE + 1)
-        die("Bad s_zmap_blocks field in super-block");
+        die("bad s_zmap_blocks field in super-block");
 }
 
@@ -680 +657 @@
     inode_count = xmalloc(INODES + 1);
     zone_count = xmalloc(ZONES);
-    if (IMAPS * BLOCK_SIZE != read(IN, inode_map, IMAPS * BLOCK_SIZE))
-        die("Unable to read inode map");
-    if (ZMAPS * BLOCK_SIZE != read(IN, zone_map, ZMAPS * BLOCK_SIZE))
-        die("Unable to read zone map");
-    if (INODE_BUFFER_SIZE != read(IN, inode_buffer, INODE_BUFFER_SIZE))
-        die("Unable to read inodes");
+    if (IMAPS * BLOCK_SIZE != read(dev_fd, inode_map, IMAPS * BLOCK_SIZE))
+        die("cannot read inode map");
+    if (ZMAPS * BLOCK_SIZE != read(dev_fd, zone_map, ZMAPS * BLOCK_SIZE))
+        die("cannot read zone map");
+    if (INODE_BUFFER_SIZE != read(dev_fd, inode_buffer, INODE_BUFFER_SIZE))
+        die("cannot read inodes");
     if (NORM_FIRSTZONE != FIRSTZONE) {
-        printf("Warning: Firstzone!=Norm_firstzone\n");
+        printf("warning: firstzone!=norm_firstzone\n");
         errors_uncorrected = 1;
     }
     get_dirsize();
     if (show) {
-        printf("%ld inodes\n"
-            "%ld blocks\n"
-            "Firstdatazone=%ld (%ld)\n"
-            "Zonesize=%d\n"
-            "Maxsize=%ld\n"
-            "Filesystem state=%d\n"
-            "namelen=%d\n\n",
+        printf("%u inodes\n"
+            "%u blocks\n"
+            "Firstdatazone=%u (%u)\n"
+            "Zonesize=%u\n"
+            "Maxsize=%u\n"
+            "Filesystem state=%u\n"
+            "namelen=%u\n\n",
             INODES,
             ZONES,
@@ -709 +686 @@
 }
 
-static struct minix_inode *get_inode(unsigned int nr)
-{
-    struct minix_inode *inode;
+static struct minix1_inode *get_inode(unsigned nr)
+{
+    struct minix1_inode *inode;
 
     if (!nr || nr > INODES)
         return NULL;
     total++;
-    inode = Inode + nr;
+    inode = Inode1 + nr;
     if (!inode_count[nr]) {
         if (!inode_in_use(nr)) {
@@ -724 +701 @@
                 if (ask("Mark as 'in use'", 1))
                     mark_inode(nr);
-            } else {
-                errors_uncorrected = 1;
+                else
+                    errors_uncorrected = 1;
             }
         }
@@ -754 +731 @@
 }
 
-#ifdef CONFIG_FEATURE_MINIX2
-static struct minix2_inode *get_inode2(unsigned int nr)
+#if ENABLE_FEATURE_MINIX2
+static struct minix2_inode *get_inode2(unsigned nr)
 {
     struct minix2_inode *inode;
@@ -802 +779 @@
 static void check_root(void)
 {
-    struct minix_inode *inode = Inode + ROOT_INO;
+    struct minix1_inode *inode = Inode1 + MINIX_ROOT_INO;
 
     if (!inode || !S_ISDIR(inode->i_mode))
-        die("Root inode isn't a directory");
-}
-
-#ifdef CONFIG_FEATURE_MINIX2
+        die("root inode isn't a directory");
+}
+
+#if ENABLE_FEATURE_MINIX2
 static void check_root2(void)
 {
-    struct minix2_inode *inode = Inode2 + ROOT_INO;
+    struct minix2_inode *inode = Inode2 + MINIX_ROOT_INO;
 
     if (!inode || !S_ISDIR(inode->i_mode))
-        die("Root inode isn't a directory");
-}
-#endif
-
-static int add_zone(uint16_t *znr, int *corrected)
+        die("root inode isn't a directory");
+}
+#else
+void check_root2(void);
+#endif
+
+static int add_zone(uint16_t *znr, smallint *corrected)
 {
     int result;
@@ -848 +827 @@
 }
 
-#ifdef CONFIG_FEATURE_MINIX2
-static int add_zone2(uint32_t *znr, int *corrected)
+#if ENABLE_FEATURE_MINIX2
+static int add_zone2(uint32_t *znr, smallint *corrected)
 {
     int result;
@@ -880 +859 @@
 #endif
 
-static void add_zone_ind(uint16_t *znr, int *corrected)
-{
-    static char blk[BLOCK_SIZE];
-    int i, chg_blk = 0;
+static void add_zone_ind(uint16_t *znr, smallint *corrected)
+{
+    int i;
     int block;
+    smallint chg_blk = 0;
 
     block = add_zone(znr, corrected);
     if (!block)
         return;
-    read_block(block, blk);
+    read_block(block, add_zone_ind_blk);
     for (i = 0; i < (BLOCK_SIZE >> 1); i++)
-        add_zone(i + (uint16_t *) blk, &chg_blk);
+        add_zone(i + (uint16_t *) add_zone_ind_blk, &chg_blk);
     if (chg_blk)
-        write_block(block, blk);
-}
-
-#ifdef CONFIG_FEATURE_MINIX2
-static void add_zone_ind2(uint32_t *znr, int *corrected)
-{
-    static char blk[BLOCK_SIZE];
-    int i, chg_blk = 0;
+        write_block(block, add_zone_ind_blk);
+}
+
+#if ENABLE_FEATURE_MINIX2
+static void add_zone_ind2(uint32_t *znr, smallint *corrected)
+{
+    int i;
     int block;
+    smallint chg_blk = 0;
 
     block = add_zone2(znr, corrected);
     if (!block)
         return;
-    read_block(block, blk);
+    read_block(block, add_zone_ind_blk);
     for (i = 0; i < BLOCK_SIZE >> 2; i++)
-        add_zone2(i + (uint32_t *) blk, &chg_blk);
+        add_zone2(i + (uint32_t *) add_zone_ind_blk, &chg_blk);
     if (chg_blk)
-        write_block(block, blk);
-}
-#endif
-
-static void add_zone_dind(uint16_t *znr, int *corrected)
-{
-    static char blk[BLOCK_SIZE];
-    int i, blk_chg = 0;
+        write_block(block, add_zone_ind_blk);
+}
+#endif
+
+static void add_zone_dind(uint16_t *znr, smallint *corrected)
+{
+    int i;
     int block;
+    smallint chg_blk = 0;
 
     block = add_zone(znr, corrected);
     if (!block)
         return;
-    read_block(block, blk);
+    read_block(block, add_zone_dind_blk);
     for (i = 0; i < (BLOCK_SIZE >> 1); i++)
-        add_zone_ind(i + (uint16_t *) blk, &blk_chg);
-    if (blk_chg)
-        write_block(block, blk);
-}
-
-#ifdef CONFIG_FEATURE_MINIX2
-static void add_zone_dind2(uint32_t *znr, int *corrected)
-{
-    static char blk[BLOCK_SIZE];
-    int i, blk_chg = 0;
+        add_zone_ind(i + (uint16_t *) add_zone_dind_blk, &chg_blk);
+    if (chg_blk)
+        write_block(block, add_zone_dind_blk);
+}
+
+#if ENABLE_FEATURE_MINIX2
+static void add_zone_dind2(uint32_t *znr, smallint *corrected)
+{
+    int i;
     int block;
+    smallint chg_blk = 0;
 
     block = add_zone2(znr, corrected);
     if (!block)
         return;
-    read_block(block, blk);
+    read_block(block, add_zone_dind_blk);
     for (i = 0; i < BLOCK_SIZE >> 2; i++)
-        add_zone_ind2(i + (uint32_t *) blk, &blk_chg);
-    if (blk_chg)
-        write_block(block, blk);
-}
-
-static void add_zone_tind2(uint32_t *znr, int *corrected)
-{
-    static char blk[BLOCK_SIZE];
-    int i, blk_chg = 0;
+        add_zone_ind2(i + (uint32_t *) add_zone_dind_blk, &chg_blk);
+    if (chg_blk)
+        write_block(block, add_zone_dind_blk);
+}
+
+static void add_zone_tind2(uint32_t *znr, smallint *corrected)
+{
+    int i;
     int block;
+    smallint chg_blk = 0;
 
     block = add_zone2(znr, corrected);
     if (!block)
         return;
-    read_block(block, blk);
+    read_block(block, add_zone_tind_blk);
     for (i = 0; i < BLOCK_SIZE >> 2; i++)
-        add_zone_dind2(i + (uint32_t *) blk, &blk_chg);
-    if (blk_chg)
-        write_block(block, blk);
-}
-#endif
-
-static void check_zones(unsigned int i)
-{
-    struct minix_inode *inode;
+        add_zone_dind2(i + (uint32_t *) add_zone_tind_blk, &chg_blk);
+    if (chg_blk)
+        write_block(block, add_zone_tind_blk);
+}
+#endif
+
+static void check_zones(unsigned i)
+{
+    struct minix1_inode *inode;
 
     if (!i || i > INODES)
@@ -972 +951 @@
     if (inode_count[i] > 1)     /* have we counted this file already? */
         return;
-    inode = Inode + i;
+    inode = Inode1 + i;
     if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
         !S_ISLNK(inode->i_mode)) return;
@@ -981 +960 @@
 }
 
-#ifdef CONFIG_FEATURE_MINIX2
-static void check_zones2(unsigned int i)
+#if ENABLE_FEATURE_MINIX2
+static void check_zones2(unsigned i)
 {
     struct minix2_inode *inode;
@@ -1002 +981 @@
 #endif
 
-static void check_file(struct minix_inode *dir, unsigned int offset)
-{
-    static char blk[BLOCK_SIZE];
-    struct minix_inode *inode;
+static void check_file(struct minix1_inode *dir, unsigned offset)
+{
+    struct minix1_inode *inode;
     int ino;
     char *name;
@@ -1011 +989 @@
 
     block = map_block(dir, offset / BLOCK_SIZE);
-    read_block(block, blk);
-    name = blk + (offset % BLOCK_SIZE) + 2;
+    read_block(block, check_file_blk);
+    name = check_file_blk + (offset % BLOCK_SIZE) + 2;
     ino = *(uint16_t *) (name - 2);
     if (ino > INODES) {
@@ -1019 +997 @@
         if (ask("Remove", 1)) {
             *(uint16_t *) (name - 2) = 0;
-            write_block(block, blk);
+            write_block(block, check_file_blk);
         }
         ino = 0;
@@ -1027 +1005 @@
     pop_filename();
     if (!offset) {
-        if (!inode || strcmp(".", name)) {
-            printf("%s: bad directory: '.' isn't first\n", current_name);
-            errors_uncorrected = 1;
-        } else
+        if (inode && LONE_CHAR(name, '.'))
             return;
+        printf("%s: bad directory: '.' isn't first\n", current_name);
+        errors_uncorrected = 1;
     }
     if (offset == dirsize) {
-        if (!inode || strcmp("..", name)) {
-            printf("%s: bad directory: '..' isn't second\n", current_name);
-            errors_uncorrected = 1;
-        } else
+        if (inode && strcmp("..", name) == 0)
             return;
+        printf("%s: bad directory: '..' isn't second\n", current_name);
+        errors_uncorrected = 1;
     }
     if (!inode)
@@ -1052 +1028 @@
         recursive_check(ino);
     pop_filename();
-    return;
-}
-
-#ifdef CONFIG_FEATURE_MINIX2
-static void check_file2(struct minix2_inode *dir, unsigned int offset)
-{
-    static char blk[BLOCK_SIZE];
+}
+
+#if ENABLE_FEATURE_MINIX2
+static void check_file2(struct minix2_inode *dir, unsigned offset)
+{
     struct minix2_inode *inode;
     int ino;
@@ -1065 +1039 @@
 
     block = map_block2(dir, offset / BLOCK_SIZE);
-    read_block(block, blk);
-    name = blk + (offset % BLOCK_SIZE) + 2;
+    read_block(block, check_file_blk);
+    name = check_file_blk + (offset % BLOCK_SIZE) + 2;
     ino = *(uint16_t *) (name - 2);
     if (ino > INODES) {
@@ -1073 +1047 @@
         if (ask("Remove", 1)) {
             *(uint16_t *) (name - 2) = 0;
-            write_block(block, blk);
+            write_block(block, check_file_blk);
         }
         ino = 0;
@@ -1081 +1055 @@
     pop_filename();
     if (!offset) {
-        if (!inode || strcmp(".", name)) {
-            printf("%s: bad directory: '.' isn't first\n", current_name);
-            errors_uncorrected = 1;
-        } else
+        if (inode && LONE_CHAR(name, '.'))
             return;
+        printf("%s: bad directory: '.' isn't first\n", current_name);
+        errors_uncorrected = 1;
     }
     if (offset == dirsize) {
-        if (!inode || strcmp("..", name)) {
-            printf("%s: bad directory: '..' isn't second\n", current_name);
-            errors_uncorrected = 1;
-        } else
+        if (inode && strcmp("..", name) == 0)
             return;
+        printf("%s: bad directory: '..' isn't second\n", current_name);
+        errors_uncorrected = 1;
     }
     if (!inode)
@@ -1106 +1078 @@
         recursive_check2(ino);
     pop_filename();
-    return;
-}
-#endif
-
-static void recursive_check(unsigned int ino)
-{
-    struct minix_inode *dir;
-    unsigned int offset;
-
-    dir = Inode + ino;
+}
+#endif
+
+static void recursive_check(unsigned ino)
+{
+    struct minix1_inode *dir;
+    unsigned offset;
+
+    dir = Inode1 + ino;
     if (!S_ISDIR(dir->i_mode))
-        die("Internal error");
+        die("internal error");
     if (dir->i_size < 2 * dirsize) {
         printf("%s: bad directory: size<32", current_name);
@@ -1126 +1097 @@
 }
 
-#ifdef CONFIG_FEATURE_MINIX2
-static void recursive_check2(unsigned int ino)
+#if ENABLE_FEATURE_MINIX2
+static void recursive_check2(unsigned ino)
 {
     struct minix2_inode *dir;
-    unsigned int offset;
+    unsigned offset;
 
     dir = Inode2 + ino;
     if (!S_ISDIR(dir->i_mode))
-        die("Internal error");
+        die("internal error");
     if (dir->i_size < 2 * dirsize) {
         printf("%s: bad directory: size<32", current_name);
@@ -1146 +1117 @@
 static int bad_zone(int i)
 {
-    char buffer[1024];
-
-    if (BLOCK_SIZE * i != lseek(IN, BLOCK_SIZE * i, SEEK_SET))
-        die("Seek failed in bad_zone");
-    return (BLOCK_SIZE != read(IN, buffer, BLOCK_SIZE));
+    char buffer[BLOCK_SIZE];
+
+    if (BLOCK_SIZE * i != lseek(dev_fd, BLOCK_SIZE * i, SEEK_SET))
+        die("seek failed in bad_zone");
+    return (BLOCK_SIZE != read(dev_fd, buffer, BLOCK_SIZE));
 }
 
@@ -1158 +1129 @@
 
     for (i = 1; i <= INODES; i++) {
-        if (warn_mode && Inode[i].i_mode && !inode_in_use(i)) {
+        if (warn_mode && Inode1[i].i_mode && !inode_in_use(i)) {
             printf("Inode %d has non-zero mode. ", i);
             if (ask("Clear", 1)) {
-                Inode[i].i_mode = 0;
+                Inode1[i].i_mode = 0;
                 changed = 1;
             }
@@ -1178 +1149 @@
                 mark_inode(i);
         }
-        if (Inode[i].i_nlinks != inode_count[i]) {
+        if (Inode1[i].i_nlinks != inode_count[i]) {
             printf("Inode %d (mode=%07o), i_nlinks=%d, counted=%d. ",
-                   i, Inode[i].i_mode, Inode[i].i_nlinks, inode_count[i]);
+                i, Inode1[i].i_mode, Inode1[i].i_nlinks,
+                inode_count[i]);
             if (ask("Set i_nlinks to count", 1)) {
-                Inode[i].i_nlinks = inode_count[i];
+                Inode1[i].i_nlinks = inode_count[i];
                 changed = 1;
             }
@@ -1188 +1160 @@
     }
     for (i = FIRSTZONE; i < ZONES; i++) {
-        if (zone_in_use(i) == zone_count[i])
+        if ((zone_in_use(i) != 0) == zone_count[i])
             continue;
         if (!zone_count[i]) {
@@ -1203 +1175 @@
 }
 
-#ifdef CONFIG_FEATURE_MINIX2
+#if ENABLE_FEATURE_MINIX2
 static void check_counts2(void)
 {
@@ -1231 +1203 @@
         if (Inode2[i].i_nlinks != inode_count[i]) {
             printf("Inode %d (mode=%07o), i_nlinks=%d, counted=%d. ",
-                   i, Inode2[i].i_mode, Inode2[i].i_nlinks,
-                   inode_count[i]);
+                i, Inode2[i].i_mode, Inode2[i].i_nlinks,
+                inode_count[i]);
             if (ask("Set i_nlinks to count", 1)) {
                 Inode2[i].i_nlinks = inode_count[i];
@@ -1240 +1212 @@
     }
     for (i = FIRSTZONE; i < ZONES; i++) {
-        if (zone_in_use(i) == zone_count[i])
+        if ((zone_in_use(i) != 0) == zone_count[i])
             continue;
         if (!zone_count[i]) {
@@ -1260 +1232 @@
     memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count));
     memset(zone_count, 0, ZONES * sizeof(*zone_count));
-    check_zones(ROOT_INO);
-    recursive_check(ROOT_INO);
+    check_zones(MINIX_ROOT_INO);
+    recursive_check(MINIX_ROOT_INO);
     check_counts();
 }
 
-#ifdef CONFIG_FEATURE_MINIX2
+#if ENABLE_FEATURE_MINIX2
 static void check2(void)
 {
     memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count));
     memset(zone_count, 0, ZONES * sizeof(*zone_count));
-    check_zones2(ROOT_INO);
-    recursive_check2(ROOT_INO);
+    check_zones2(MINIX_ROOT_INO);
+    recursive_check2(MINIX_ROOT_INO);
     check_counts2();
 }
-#endif
-
+#else
+void check2(void);
+#endif
+
+int fsck_minix_main(int argc, char **argv);
 int fsck_minix_main(int argc, char **argv)
 {
@@ -1281 +1256 @@
     int retcode = 0;
 
-    alloc_current_name();
-#ifdef CONFIG_FEATURE_CLEAN_UP
-    /* Don't bother to free memory.  Exit does
-     * that automagically, so we can save a few bytes */
-    atexit(free_current_name);
-#endif
-
-    if (INODE_SIZE * MINIX_INODES_PER_BLOCK != BLOCK_SIZE)
-        die("Bad inode size");
-#ifdef CONFIG_FEATURE_MINIX2
+    xfunc_error_retval = 8;
+
+    INIT_G();
+
+    if (INODE_SIZE1 * MINIX1_INODES_PER_BLOCK != BLOCK_SIZE)
+        die("bad inode size");
+#if ENABLE_FEATURE_MINIX2
     if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE)
-        die("Bad v2 inode size");
-#endif
-    while (argc-- > 1) {
+        die("bad v2 inode size");
+#endif
+    while (--argc != 0) {
         argv++;
         if (argv[0][0] != '-') {
             if (device_name)
                 bb_show_usage();
-            else
-                device_name = argv[0];
-        } else
-            while (*++argv[0])
+            device_name = argv[0];
+        } else {
+            while (*++argv[0]) {
                 switch (argv[0][0]) {
                 case 'l':
@@ -1330 +1301 @@
                     bb_show_usage();
                 }
+            }
+        }
     }
     if (!device_name)
         bb_show_usage();
+
     check_mount();              /* trying to check a mounted filesystem? */
     if (repair && !automatic) {
         if (!isatty(0) || !isatty(1))
-            die("Need terminal for interactive repairs");
-    }
-    IN = open(device_name, repair ? O_RDWR : O_RDONLY);
-    if (IN < 0){
-        printf("Unable to open device '%s'\n", device_name);
-        leave(8);
-    }
-    sync(); /* paranoia? */
+            die("need terminal for interactive repairs");
+    }
+    dev_fd = xopen(device_name, repair ? O_RDWR : O_RDONLY);
+
+    /*sync(); paranoia? */
     read_superblock();
 
@@ -1352 +1323 @@
      * command line.
      */
-    printf("%s, %s\n", bb_applet_name, program_version);
-    if (!(Super.s_state & MINIX_ERROR_FS) &&
-        (Super.s_state & MINIX_VALID_FS) && !force) {
+    printf("%s: %s\n", applet_name, bb_banner);
+
+    if (!(Super.s_state & MINIX_ERROR_FS)
+     && (Super.s_state & MINIX_VALID_FS) && !force
+    ) {
         if (repair)
             printf("%s is clean, check is skipped\n", device_name);
-        return retcode;
+        return 0;
     } else if (force)
         printf("Forcing filesystem check on %s\n", device_name);
@@ -1367 +1340 @@
 
     if (repair && !automatic) {
-        tcgetattr(0, &termios);
-        tmp = termios;
+        tcgetattr(0, &sv_termios);
+        tmp = sv_termios;
         tmp.c_lflag &= ~(ICANON | ECHO);
         tcsetattr(0, TCSANOW, &tmp);
         termios_set = 1;
     }
-#ifdef CONFIG_FEATURE_MINIX2
+
     if (version2) {
         check_root2();
         check2();
-    } else
-#endif
-    {
+    } else {
         check_root();
         check();
     }
+
     if (verbose) {
         int i, free_cnt;
@@ -1389 +1361 @@
             if (!inode_in_use(i))
                 free_cnt++;
-        printf("\n%6ld inodes used (%ld%%)\n", (INODES - free_cnt),
+        printf("\n%6u inodes used (%u%%)\n", (INODES - free_cnt),
                100 * (INODES - free_cnt) / INODES);
         for (i = FIRSTZONE, free_cnt = 0; i < ZONES; i++)
             if (!zone_in_use(i))
                 free_cnt++;
-        printf("%6ld zones used (%ld%%)\n\n"
-               "%6d regular files\n"
-               "%6d directories\n"
-               "%6d character device files\n"
-               "%6d block device files\n"
-               "%6d links\n"
-               "%6d symbolic links\n"
+        printf("%6u zones used (%u%%)\n\n"
+               "%6u regular files\n"
+               "%6u directories\n"
+               "%6u character device files\n"
+               "%6u block device files\n"
+               "%6u links\n"
+               "%6u symbolic links\n"
                "------\n"
-               "%6d files\n",
+               "%6u files\n",
                (ZONES - free_cnt), 100 * (ZONES - free_cnt) / ZONES,
                regular, directory, chardev, blockdev,
@@ -1416 +1388 @@
 
     if (repair && !automatic)
-        tcsetattr(0, TCSANOW, &termios);
+        tcsetattr(0, TCSANOW, &sv_termios);
 
     if (changed)

branches/2.2.5/mindi-busybox/util-linux/getopt.c

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /*
  * getopt.c - Enhanced implementation of BSD getopt(1)
@@ -31 +32 @@
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <ctype.h>
 #include <getopt.h>
-
-#include "busybox.h"
+#include "libbb.h"
 
 /* NON_OPT is the code that is returned when a non-option is found in '+'
@@ -44 +39 @@
 enum {
     NON_OPT = 1,
+#if ENABLE_GETOPT_LONG
 /* LONG_OPT is the code that is returned when a long option is found. */
     LONG_OPT = 2
+#endif
 };
 
-/* The shells recognized. */
-typedef enum {BASH,TCSH} shell_t;
-
-
-/* Some global variables that tells us how to parse. */
-static shell_t shell=BASH; /* The shell we generate output for. */
-static int quiet_errors; /* 0 is not quiet. */
-static int quiet_output; /* 0 is not quiet. */
-static int quote=1; /* 1 is do quote. */
-static int alternative; /* 0 is getopt_long, 1 is getopt_long_only */
-
-/* Function prototypes */
-static const char *normalize(const char *arg);
-static int generate_output(char * argv[],int argc,const char *optstr,
-            const struct option *longopts);
-static void add_long_options(char *options);
-static void add_longopt(const char *name,int has_arg);
-static void set_shell(const char *new_shell);
-
+/* For finding activated option flags. Must match getopt32 call! */
+enum {
+    OPT_o   = 0x1,  // -o
+    OPT_n   = 0x2,  // -n
+    OPT_q   = 0x4,  // -q
+    OPT_Q   = 0x8,  // -Q
+    OPT_s   = 0x10, // -s
+    OPT_T   = 0x20, // -T
+    OPT_u   = 0x40, // -u
+#if ENABLE_GETOPT_LONG
+    OPT_a   = 0x80, // -a
+    OPT_l   = 0x100, // -l
+#endif
+    SHELL_IS_TCSH = 0x8000, /* hijack this bit for other purposes */
+};
+
+/* 0 is getopt_long, 1 is getopt_long_only */
+#define alternative  (option_mask32 & OPT_a)
+
+#define quiet_errors (option_mask32 & OPT_q)
+#define quiet_output (option_mask32 & OPT_Q)
+#define quote        (!(option_mask32 & OPT_u))
+#define shell_TCSH   (option_mask32 & SHELL_IS_TCSH)
 
 /*
@@ -77 +78 @@
  * each call.
  */
-const char *normalize(const char *arg)
-{
-    static char *BUFFER=NULL;
-    const char *argptr=arg;
+static const char *normalize(const char *arg)
+{
     char *bufptr;
-
+#if ENABLE_FEATURE_CLEAN_UP
+    static char *BUFFER = NULL;
     free(BUFFER);
+#else
+    char *BUFFER;
+#endif
 
     if (!quote) { /* Just copy arg */
-           BUFFER=bb_xstrdup(arg);
+        BUFFER = xstrdup(arg);
         return BUFFER;
     }
@@ -94 +97 @@
        opening quote! We need also the global opening and closing quote,
        and one extra character for '\0'. */
-    BUFFER=xmalloc(strlen(arg)*4+3);
-
-    bufptr=BUFFER;
-    *bufptr++='\'';
-
-    while (*argptr) {
-        if (*argptr == '\'') {
+    BUFFER = xmalloc(strlen(arg)*4 + 3);
+
+    bufptr = BUFFER;
+    *bufptr ++= '\'';
+
+    while (*arg) {
+        if (*arg == '\'') {
             /* Quote: replace it with: '\'' */
-            *bufptr++='\'';
-            *bufptr++='\\';
-            *bufptr++='\'';
-            *bufptr++='\'';
-        } else if (shell==TCSH && *argptr=='!') {
+            *bufptr ++= '\'';
+            *bufptr ++= '\\';
+            *bufptr ++= '\'';
+            *bufptr ++= '\'';
+        } else if (shell_TCSH && *arg == '!') {
             /* Exclamation mark: replace it with: \! */
-            *bufptr++='\'';
-            *bufptr++='\\';
-            *bufptr++='!';
-            *bufptr++='\'';
-        } else if (shell==TCSH && *argptr=='\n') {
+            *bufptr ++= '\'';
+            *bufptr ++= '\\';
+            *bufptr ++= '!';
+            *bufptr ++= '\'';
+        } else if (shell_TCSH && *arg == '\n') {
             /* Newline: replace it with: \n */
-            *bufptr++='\\';
-            *bufptr++='n';
-        } else if (shell==TCSH && isspace(*argptr)) {
+            *bufptr ++= '\\';
+            *bufptr ++= 'n';
+        } else if (shell_TCSH && isspace(*arg)) {
             /* Non-newline whitespace: replace it with \<ws> */
-            *bufptr++='\'';
-            *bufptr++='\\';
-            *bufptr++=*argptr;
-            *bufptr++='\'';
+            *bufptr ++= '\'';
+            *bufptr ++= '\\';
+            *bufptr ++= *arg;
+            *bufptr ++= '\'';
         } else
             /* Just copy */
-            *bufptr++=*argptr;
-        argptr++;
-    }
-    *bufptr++='\'';
-    *bufptr++='\0';
+            *bufptr ++= *arg;
+        arg++;
+    }
+    *bufptr ++= '\'';
+    *bufptr ++= '\0';
     return BUFFER;
 }
@@ -139 +142 @@
  * Other settings are found in global variables.
  */
-int generate_output(char * argv[],int argc,const char *optstr,
-            const struct option *longopts)
+#if !ENABLE_GETOPT_LONG
+#define generate_output(argv,argc,optstr,longopts) generate_output(argv,argc,optstr)
+#endif
+static int generate_output(char **argv, int argc, const char *optstr, const struct option *longopts)
 {
     int exit_code = 0; /* We assume everything will be OK */
-    int opt;
+    unsigned opt;
+#if ENABLE_GETOPT_LONG
     int longindex;
+#endif
     const char *charptr;
 
     if (quiet_errors) /* No error reporting from getopt(3) */
-        opterr=0;
-    optind=0; /* Reset getopt(3) */
-
-    while ((opt = (alternative?
-               getopt_long_only(argc,argv,optstr,longopts,&longindex):
-               getopt_long(argc,argv,optstr,longopts,&longindex)))
-           != EOF)
+        opterr = 0;
+    optind = 0; /* Reset getopt(3) */
+
+    while (1) {
+        opt =
+#if ENABLE_GETOPT_LONG
+            alternative ?
+            getopt_long_only(argc, argv, optstr, longopts, &longindex) :
+            getopt_long(argc, argv, optstr, longopts, &longindex);
+#else
+            getopt(argc, argv, optstr);
+#endif
+        if (opt == EOF)
+            break;
         if (opt == '?' || opt == ':' )
             exit_code = 1;
         else if (!quiet_output) {
+#if ENABLE_GETOPT_LONG
             if (opt == LONG_OPT) {
-                printf(" --%s",longopts[longindex].name);
+                printf(" --%s", longopts[longindex].name);
                 if (longopts[longindex].has_arg)
                     printf(" %s",
-                           normalize(optarg?optarg:""));
-            } else if (opt == NON_OPT)
-                printf(" %s",normalize(optarg));
+                        normalize(optarg ? optarg : ""));
+            } else
+#endif
+            if (opt == NON_OPT)
+                printf(" %s", normalize(optarg));
             else {
-                printf(" -%c",opt);
+                printf(" -%c", opt);
                 charptr = strchr(optstr,opt);
                 if (charptr != NULL && *++charptr == ':')
                     printf(" %s",
-                           normalize(optarg?optarg:""));
+                        normalize(optarg ? optarg : ""));
             }
         }
-
-    if (! quiet_output) {
+    }
+
+    if (!quiet_output) {
         printf(" --");
         while (optind < argc)
-            printf(" %s",normalize(argv[optind++]));
-        printf("\n");
+            printf(" %s", normalize(argv[optind++]));
+        puts("");
     }
     return exit_code;
 }
 
-static struct option *long_options;
-static int long_options_length; /* Length of array */
-static int long_options_nr; /* Nr of used elements in array */
-enum { LONG_OPTIONS_INCR = 10 };
-#define init_longopt() add_longopt(NULL,0)
-
-/* Register a long option. The contents of name is copied. */
-void add_longopt(const char *name,int has_arg)
-{
-    if (!name) { /* init */
-        free(long_options);
-        long_options=NULL;
-        long_options_length=0;
-        long_options_nr=0;
-    }
-
-    if (long_options_nr == long_options_length) {
-        long_options_length += LONG_OPTIONS_INCR;
-        long_options=xrealloc(long_options,
-                     sizeof(struct option) *
-                     long_options_length);
-    }
-
-    long_options[long_options_nr].name=NULL;
-    long_options[long_options_nr].has_arg=0;
-    long_options[long_options_nr].flag=NULL;
-    long_options[long_options_nr].val=0;
-
-    if (long_options_nr) { /* Not for init! */
-        long_options[long_options_nr-1].has_arg=has_arg;
-        long_options[long_options_nr-1].flag=NULL;
-        long_options[long_options_nr-1].val=LONG_OPT;
-           long_options[long_options_nr-1].name=bb_xstrdup(name);
-    }
-    long_options_nr++;
-}
-
-
+#if ENABLE_GETOPT_LONG
 /*
  * Register several long options. options is a string of long options,
@@ -226 +207 @@
  * This nukes options!
  */
-void add_long_options(char *options)
-{
+static struct option *add_long_options(struct option *long_options, char *options)
+{
+    int long_nr = 0;
     int arg_opt, tlen;
-    char *tokptr=strtok(options,", \t\n");
+    char *tokptr = strtok(options, ", \t\n");
+
+    if (long_options)
+        while (long_options[long_nr].name)
+            long_nr++;
+
     while (tokptr) {
-        arg_opt=no_argument;
-        tlen=strlen(tokptr);
-        if (tlen > 0) {
-            if (tokptr[tlen-1] == ':') {
-                if (tlen > 1 && tokptr[tlen-2] == ':') {
-                    tokptr[tlen-2]='\0';
-                    tlen -= 2;
-                    arg_opt=optional_argument;
-                } else {
-                    tokptr[tlen-1]='\0';
-                    tlen -= 1;
-                    arg_opt=required_argument;
+        arg_opt = no_argument;
+        tlen = strlen(tokptr);
+        if (tlen) {
+            tlen--;
+            if (tokptr[tlen] == ':') {
+                arg_opt = required_argument;
+                if (tlen && tokptr[tlen-1] == ':') {
+                    tlen--;
+                    arg_opt = optional_argument;
                 }
+                tokptr[tlen] = '\0';
                 if (tlen == 0)
-                    bb_error_msg("empty long option after -l or --long argument");
+                    bb_error_msg_and_die("empty long option specified");
             }
-            add_longopt(tokptr,arg_opt);
+            long_options = xrealloc(long_options,
+                    sizeof(long_options[0]) * (long_nr+2));
+            long_options[long_nr].has_arg = arg_opt;
+            long_options[long_nr].flag = NULL;
+            long_options[long_nr].val = LONG_OPT;
+            long_options[long_nr].name = xstrdup(tokptr);
+            long_nr++;
+            memset(&long_options[long_nr], 0, sizeof(long_options[0]));
         }
-        tokptr=strtok(NULL,", \t\n");
-    }
-}
-
-void set_shell(const char *new_shell)
-{
-    if (!strcmp(new_shell,"bash"))
-        shell=BASH;
-    else if (!strcmp(new_shell,"tcsh"))
-        shell=TCSH;
-    else if (!strcmp(new_shell,"sh"))
-        shell=BASH;
-    else if (!strcmp(new_shell,"csh"))
-        shell=TCSH;
+        tokptr = strtok(NULL, ", \t\n");
+    }
+    return long_options;
+}
+#endif
+
+static void set_shell(const char *new_shell)
+{
+    if (!strcmp(new_shell,"bash") || !strcmp(new_shell,"sh"))
+        return;
+    if (!strcmp(new_shell,"tcsh") || !strcmp(new_shell,"csh"))
+        option_mask32 |= SHELL_IS_TCSH;
     else
-        bb_error_msg("unknown shell after -s or --shell argument");
+        bb_error_msg("unknown shell '%s', assuming bash", new_shell);
 }
 
@@ -276 +266 @@
  */
 
-static const struct option longopts[]=
-{
-    {"options",required_argument,NULL,'o'},
-    {"longoptions",required_argument,NULL,'l'},
-    {"quiet",no_argument,NULL,'q'},
-    {"quiet-output",no_argument,NULL,'Q'},
-    {"shell",required_argument,NULL,'s'},
-    {"test",no_argument,NULL,'T'},
-    {"unquoted",no_argument,NULL,'u'},
-    {"alternative",no_argument,NULL,'a'},
-    {"name",required_argument,NULL,'n'},
-    {NULL,0,NULL,0}
-};
-
-/* Stop scanning as soon as a non-option argument is found! */
-static const char shortopts[]="+ao:l:n:qQs:Tu";
-
-
+#if ENABLE_GETOPT_LONG
+static const char getopt_longopts[] ALIGN1 =
+    "options\0"      Required_argument "o"
+    "longoptions\0"  Required_argument "l"
+    "quiet\0"        No_argument       "q"
+    "quiet-output\0" No_argument       "Q"
+    "shell\0"        Required_argument "s"
+    "test\0"         No_argument       "T"
+    "unquoted\0"     No_argument       "u"
+    "alternative\0"  No_argument       "a"
+    "name\0"         Required_argument "n"
+    ;
+#endif
+
+int getopt_main(int argc, char *argv[]);
 int getopt_main(int argc, char *argv[])
 {
-    const char *optstr = NULL;
+    char *optstr = NULL;
     char *name = NULL;
-    int opt;
-    int compatible=0;
-
-    init_longopt();
-
-    if (getenv("GETOPT_COMPATIBLE"))
-        compatible=1;
+    unsigned opt;
+    const char *compatible;
+    char *s_arg;
+#if ENABLE_GETOPT_LONG
+    struct option *long_options = NULL;
+    llist_t *l_arg = NULL;
+#endif
+
+    compatible = getenv("GETOPT_COMPATIBLE"); /* used as yes/no flag */
 
     if (argc == 1) {
@@ -311 +300 @@
                when there were no arguments. */
             printf(" --\n");
-               return 0;
-        } else
-            bb_error_msg_and_die("missing optstring argument");
+            return 0;
+        }
+        bb_error_msg_and_die("missing optstring argument");
     }
 
@@ -319 +308 @@
         char *s;
 
-        quote=0;
-        s=xmalloc(strlen(argv[1])+1);
-        strcpy(s,argv[1]+strspn(argv[1],"-+"));
-        argv[1]=argv[0];
-           return (generate_output(argv+1,argc-1,s,long_options));
-    }
-
-    while ((opt=getopt_long(argc,argv,shortopts,longopts,NULL)) != EOF)
-        switch (opt) {
-        case 'a':
-            alternative=1;
-            break;
-        case 'o':
-               optstr = optarg;
-            break;
-        case 'l':
-            add_long_options(optarg);
-            break;
-        case 'n':
-               name = optarg;
-            break;
-        case 'q':
-            quiet_errors=1;
-            break;
-        case 'Q':
-            quiet_output=1;
-            break;
-        case 's':
-            set_shell(optarg);
-            break;
-        case 'T':
-               return 4;
-        case 'u':
-            quote=0;
-            break;
-        default:
-            bb_show_usage();
-        }
-
+        option_mask32 |= OPT_u; /* quoting off */
+        s = xstrdup(argv[1] + strspn(argv[1], "-+"));
+        argv[1] = argv[0];
+        return generate_output(argv+1, argc-1, s, long_options);
+    }
+
+#if !ENABLE_GETOPT_LONG
+    opt = getopt32(argv, "+o:n:qQs:Tu", &optstr, &name, &s_arg);
+#else
+    applet_long_options = getopt_longopts;
+    opt_complementary = "l::";
+    opt = getopt32(argv, "+o:n:qQs:Tual:",
+                    &optstr, &name, &s_arg, &l_arg);
+    /* Effectuate the read options for the applet itself */
+    while (l_arg) {
+        long_options = add_long_options(long_options, l_arg->data);
+        l_arg = l_arg->link;
+    }
+#endif
+
+    if (opt & OPT_s) {
+        set_shell(s_arg);
+    }
+
+    if (opt & OPT_T) {
+        return 4;
+    }
+
+    /* All options controlling the applet have now been parsed */
     if (!optstr) {
         if (optind >= argc)
             bb_error_msg_and_die("missing optstring argument");
-        else optstr=argv[optind++];
-    }
-    if (name)
-        argv[optind-1]=name;
-    else
-        argv[optind-1]=argv[0];
-       return (generate_output(argv+optind-1,argc-optind+1,optstr,long_options));
-}
+        optstr = argv[optind++];
+    }
+
+    argv[optind-1] = name ? name : argv[0];
+    return generate_output(argv+optind-1, argc-optind+1, optstr, long_options);
+}

branches/2.2.5/mindi-busybox/util-linux/hexdump.c

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /*
  * hexdump implementation for busybox
@@ -9 +10 @@
  */
 
-#include "busybox.h"
 #include <getopt.h>
-#include <string.h>
+#include "libbb.h"
 #include "dump.h"
+
+/* This is a NOEXEC applet. Be very careful! */
+
 
 static void bb_dump_addfile(char *name)
 {
-    register char *p;
+    char *p;
     FILE *fp;
     char *buf;
 
-    fp = bb_xfopen(name, "r");
+    fp = xfopen(name, "r");
 
-    while ((buf = bb_get_chomped_line_from_file(fp)) != NULL) {
+    while ((buf = xmalloc_getline(fp)) != NULL) {
         p = skip_whitespace(buf);
 
@@ -33 +36 @@
 }
 
-static const char * const add_strings[] = {
-            "\"%07.7_ax \" 16/1 \"%03o \" \"\\n\"",     /* b */
-            "\"%07.7_ax \" 16/1 \"%3_c \" \"\\n\"",     /* c */
-            "\"%07.7_ax \" 8/2 \"  %05u \" \"\\n\"",    /* d */
-            "\"%07.7_ax \" 8/2 \" %06o \" \"\\n\"",     /* o */
-            "\"%07.7_ax \" 8/2 \"   %04x \" \"\\n\"",   /* x */
+static const char *const add_strings[] = {
+    "\"%07.7_ax \" 16/1 \"%03o \" \"\\n\"",     /* b */
+    "\"%07.7_ax \" 16/1 \"%3_c \" \"\\n\"",     /* c */
+    "\"%07.7_ax \" 8/2 \"  %05u \" \"\\n\"",    /* d */
+    "\"%07.7_ax \" 8/2 \" %06o \" \"\\n\"",     /* o */
+    "\"%07.7_ax \" 8/2 \"   %04x \" \"\\n\"",   /* x */
 };
 
-static const char add_first[] = "\"%07.7_Ax\n\"";
+static const char add_first[] ALIGN1 = "\"%07.7_Ax\n\"";
 
-static const char hexdump_opts[] = "bcdoxCe:f:n:s:v";
+static const char hexdump_opts[] ALIGN1 = "bcdoxCe:f:n:s:v";
 
 static const struct suffix_mult suffixes[] = {
-    {"b",  512 },
-    {"k",  1024 },
-    {"m",  1024*1024 },
-    {NULL, 0 }
+    { "b", 512 },
+    { "k", 1024 },
+    { "m", 1024*1024 },
+    { }
 };
 
+int hexdump_main(int argc, char **argv);
 int hexdump_main(int argc, char **argv)
 {
-//  register FS *tfs;
     const char *p;
     int ch;
@@ -62 +65 @@
 
     while ((ch = getopt(argc, argv, hexdump_opts)) > 0) {
-        if ((p = strchr(hexdump_opts, ch)) != NULL) {
-            if ((p - hexdump_opts) < 5) {
-                bb_dump_add(add_first);
-                bb_dump_add(add_strings[(int)(p - hexdump_opts)]);
-            } else if (ch == 'C') {
-                    bb_dump_add("\"%08.8_Ax\n\"");
-                bb_dump_add("\"%08.8_ax  \" 8/1 \"%02x \" \"  \" 8/1 \"%02x \" ");
-                    bb_dump_add("\"  |\" 16/1 \"%_p\" \"|\\n\"");
-            } else {
-                /* Sae a little bit of space below by omitting the 'else's. */
-                if (ch == 'e') {
-                    bb_dump_add(optarg);
-                } /* else */
-                if (ch == 'f') {
-                    bb_dump_addfile(optarg);
-                } /* else */
-                if (ch == 'n') {
-                    bb_dump_length = bb_xgetularg10_bnd(optarg, 0, INT_MAX);
-                } /* else */
-                if (ch == 's') {
-                    bb_dump_skip = bb_xgetularg_bnd_sfx(optarg, 10, 0, LONG_MAX, suffixes);
-                } /* else */
-                if (ch == 'v') {
-                    bb_dump_vflag = ALL;
-                }
+        p = strchr(hexdump_opts, ch);
+        if (!p)
+            bb_show_usage();
+        if ((p - hexdump_opts) < 5) {
+            bb_dump_add(add_first);
+            bb_dump_add(add_strings[(int)(p - hexdump_opts)]);
+        } else if (ch == 'C') {
+            bb_dump_add("\"%08.8_Ax\n\"");
+            bb_dump_add("\"%08.8_ax  \" 8/1 \"%02x \" \"  \" 8/1 \"%02x \" ");
+            bb_dump_add("\"  |\" 16/1 \"%_p\" \"|\\n\"");
+        } else {
+            /* Save a little bit of space below by omitting the 'else's. */
+            if (ch == 'e') {
+                bb_dump_add(optarg);
+            } /* else */
+            if (ch == 'f') {
+                bb_dump_addfile(optarg);
+            } /* else */
+            if (ch == 'n') {
+                bb_dump_length = xatoi_u(optarg);
+            } /* else */
+            if (ch == 's') {
+                bb_dump_skip = xatoul_range_sfx(optarg, 0, LONG_MAX, suffixes);
+            } /* else */
+            if (ch == 'v') {
+                bb_dump_vflag = ALL;
             }
-        } else {
-            bb_show_usage();
         }
     }
@@ -100 +102 @@
     argv += optind;
 
-    return(bb_dump_dump(argv));
+    return bb_dump_dump(argv);
 }

branches/2.2.5/mindi-busybox/util-linux/hwclock.c

@@ -8 +8 @@
 */
 
-
-#include <sys/ioctl.h>
 #include <sys/utsname.h>
-#include <ctype.h>
-#include <fcntl.h>
 #include <getopt.h>
-#include <stdlib.h>
-#include <string.h>
-#include <syslog.h>
-#include <time.h>
-#include <unistd.h>
-#include "busybox.h"
+#include "libbb.h"
 
 /* Copied from linux/rtc.h to eliminate the kernel dependency */
@@ -43 +34 @@
 #endif
 
+static const char *rtcname;
+
+static int xopen_rtc(int flags)
+{
+    int rtc;
+
+    if (!rtcname) {
+        rtc = open("/dev/rtc", flags);
+        if (rtc >= 0)
+            return rtc;
+        rtc = open("/dev/rtc0", flags);
+        if (rtc >= 0)
+            return rtc;
+        rtcname = "/dev/misc/rtc";
+    }
+    return xopen(rtcname, flags);
+}
+
 static time_t read_rtc(int utc)
 {
-    int rtc;
     struct tm tm;
     char *oldtz = 0;
     time_t t = 0;
-
-    if (( rtc = open ( "/dev/rtc", O_RDONLY )) < 0 ) {
-        if (( rtc = open ( "/dev/misc/rtc", O_RDONLY )) < 0 )
-            bb_perror_msg_and_die ( "Could not access RTC" );
-    }
-    memset ( &tm, 0, sizeof( struct tm ));
-    if ( ioctl ( rtc, RTC_RD_TIME, &tm ) < 0 )
-        bb_perror_msg_and_die ( "Could not read time from RTC" );
+    int rtc = xopen_rtc(O_RDONLY);
+
+    memset(&tm, 0, sizeof(struct tm));
+    xioctl(rtc, RTC_RD_TIME, &tm);
     tm.tm_isdst = -1; /* not known */
 
-    close ( rtc );
-
-    if ( utc ) {
-        oldtz = getenv ( "TZ" );
-        setenv ( "TZ", "UTC 0", 1 );
-        tzset ( );
-    }
-
-    t = mktime ( &tm );
-
-    if ( utc ) {
-        if ( oldtz )
-            setenv ( "TZ", oldtz, 1 );
-        else
-            unsetenv ( "TZ" );
-        tzset ( );
+    close(rtc);
+
+    if (utc) {
+        oldtz = getenv("TZ");
+        putenv((char*)"TZ=UTC0");
+        tzset();
+    }
+
+    t = mktime(&tm);
+
+    if (utc) {
+        unsetenv("TZ");
+        if (oldtz)
+            putenv(oldtz - 3);
+        tzset();
     }
     return t;
@@ -81 +84 @@
 static void write_rtc(time_t t, int utc)
 {
-    int rtc;
     struct tm tm;
-
-    if (( rtc = open ( "/dev/rtc", O_WRONLY )) < 0 ) {
-        if (( rtc = open ( "/dev/misc/rtc", O_WRONLY )) < 0 )
-            bb_perror_msg_and_die ( "Could not access RTC" );
-    }
-
-    tm = *( utc ? gmtime ( &t ) : localtime ( &t ));
+    int rtc = xopen_rtc(O_WRONLY);
+
+    tm = *(utc ? gmtime(&t) : localtime(&t));
     tm.tm_isdst = 0;
 
-    if ( ioctl ( rtc, RTC_SET_TIME, &tm ) < 0 )
-        bb_perror_msg_and_die ( "Could not set the RTC time" );
-
-    close ( rtc );
-}
-
-static int show_clock(int utc)
-{
-    struct tm *ptm;
+    xioctl(rtc, RTC_SET_TIME, &tm);
+
+    close(rtc);
+}
+
+static void show_clock(int utc)
+{
+    //struct tm *ptm;
     time_t t;
-    RESERVE_CONFIG_BUFFER(buffer, 64);
-
-    t = read_rtc ( utc );
-    ptm = localtime ( &t );  /* Sets 'tzname[]' */
-
-    safe_strncpy ( buffer, ctime ( &t ), 64);
-    if ( buffer [0] )
-        buffer [strlen ( buffer ) - 1] = 0;
-
-    //printf ( "%s  %.6f seconds %s\n", buffer, 0.0, utc ? "" : ( ptm-> tm_isdst ? tzname [1] : tzname [0] ));
-    printf ( "%s  %.6f seconds\n", buffer, 0.0 );
-    RELEASE_CONFIG_BUFFER(buffer);
-
-    return 0;
-}
-
-static int to_sys_clock(int utc)
-{
-    struct timeval tv = { 0, 0 };
+    char *cp;
+
+    t = read_rtc(utc);
+    //ptm = localtime(&t);  /* Sets 'tzname[]' */
+
+    cp = ctime(&t);
+    if (cp[0])
+        cp[strlen(cp) - 1] = '\0';
+
+    //printf("%s  %.6f seconds %s\n", cp, 0.0, utc ? "" : (ptm->tm_isdst ? tzname[1] : tzname[0]));
+    printf("%s  0.000000 seconds\n", cp);
+}
+
+static void to_sys_clock(int utc)
+{
+    struct timeval tv;
     const struct timezone tz = { timezone/60 - 60*daylight, 0 };
 
-    tv.tv_sec = read_rtc ( utc );
-
-    if ( settimeofday ( &tv, &tz ))
-        bb_perror_msg_and_die ( "settimeofday() failed" );
-
-    return 0;
-}
-
-static int from_sys_clock(int utc)
-{
-    struct timeval tv = { 0, 0 };
-    struct timezone tz = { 0, 0 };
-
-    if ( gettimeofday ( &tv, &tz ))
-        bb_perror_msg_and_die ( "gettimeofday() failed" );
-
-    write_rtc ( tv.tv_sec, utc );
-    return 0;
-}
-
-#ifdef CONFIG_FEATURE_HWCLOCK_ADJTIME_FHS
+    tv.tv_sec = read_rtc(utc);
+    tv.tv_usec = 0;
+    if (settimeofday(&tv, &tz))
+        bb_perror_msg_and_die("settimeofday() failed");
+}
+
+static void from_sys_clock(int utc)
+{
+    struct timeval tv;
+
+    gettimeofday(&tv, NULL);
+    //if (gettimeofday(&tv, NULL))
+    //  bb_perror_msg_and_die("gettimeofday() failed");
+    write_rtc(tv.tv_sec, utc);
+}
+
+#if ENABLE_FEATURE_HWCLOCK_ADJTIME_FHS
 # define ADJTIME_PATH "/var/lib/hwclock/adjtime"
 #else
@@ -151 +141 @@
 {
     int utc = 0;
-    FILE *f = fopen ( ADJTIME_PATH, "r" );
-
-    if ( f ) {
+    FILE *f = fopen(ADJTIME_PATH, "r");
+
+    if (f) {
         RESERVE_CONFIG_BUFFER(buffer, 128);
 
-        while ( fgets ( buffer, sizeof( buffer ), f )) {
-            int len = strlen ( buffer );
-
-            while ( len && isspace ( buffer [len - 1] ))
+        while (fgets(buffer, sizeof(buffer), f)) {
+            int len = strlen(buffer);
+
+            while (len && isspace(buffer[len - 1]))
                 len--;
 
-            buffer [len] = 0;
-
-            if ( strncmp ( buffer, "UTC", 3 ) == 0 ) {
+            buffer[len] = 0;
+
+            if (strncmp(buffer, "UTC", 3) == 0) {
                 utc = 1;
                 break;
             }
         }
-        fclose ( f );
+        fclose(f);
         RELEASE_CONFIG_BUFFER(buffer);
     }
@@ -175 +165 @@
 }
 
-#define HWCLOCK_OPT_LOCALTIME   0x01
-#define HWCLOCK_OPT_UTC         0x02
-#define HWCLOCK_OPT_SHOW        0x04
-#define HWCLOCK_OPT_HCTOSYS     0x08
-#define HWCLOCK_OPT_SYSTOHC     0x10
-
-int hwclock_main ( int argc, char **argv )
-{
-    unsigned long opt;
+#define HWCLOCK_OPT_LOCALTIME   0x01
+#define HWCLOCK_OPT_UTC         0x02
+#define HWCLOCK_OPT_SHOW        0x04
+#define HWCLOCK_OPT_HCTOSYS     0x08
+#define HWCLOCK_OPT_SYSTOHC     0x10
+#define HWCLOCK_OPT_RTCFILE     0x20
+
+int hwclock_main(int argc, char **argv);
+int hwclock_main(int argc, char **argv)
+{
+    unsigned opt;
     int utc;
 
 #if ENABLE_FEATURE_HWCLOCK_LONG_OPTIONS
-static const struct option hwclock_long_options[] = {
-        { "localtime", 0, 0, 'l' },
-        { "utc",       0, 0, 'u' },
-        { "show",      0, 0, 'r' },
-        { "hctosys",   0, 0, 's' },
-        { "systohc",   0, 0, 'w' },
-        { 0,           0, 0, 0 }
-    };
-    bb_applet_long_options = hwclock_long_options;
+    static const char hwclock_longopts[] ALIGN1 =
+        "localtime\0" No_argument "l"
+        "utc\0"       No_argument "u"
+        "show\0"      No_argument "r"
+        "hctosys\0"   No_argument "s"
+        "systohc\0"   No_argument "w"
+        "file\0"      Required_argument "f"
+        ;
+    applet_long_options = hwclock_longopts;
 #endif
-
-    bb_opt_complementally = "?:r--ws:w--rs:s--wr:l--u:u--l";
-    opt = bb_getopt_ulflags(argc, argv, "lursw");
+    opt_complementary = "r--ws:w--rs:s--wr:l--u:u--l";
+    opt = getopt32(argv, "lurswf:", &rtcname);
 
     /* If -u or -l wasn't given check if we are using utc */
@@ -208 +199 @@
 
     if (opt & HWCLOCK_OPT_HCTOSYS) {
-        return to_sys_clock ( utc );
-    }
-    else if (opt & HWCLOCK_OPT_SYSTOHC) {
-        return from_sys_clock ( utc );
-    } else {
-        /* default HWCLOCK_OPT_SHOW */
-        return show_clock ( utc );
-    }
-}
+        to_sys_clock(utc);
+        return 0;
+    }
+    if (opt & HWCLOCK_OPT_SYSTOHC) {
+        from_sys_clock(utc);
+        return 0;
+    }
+    /* default HWCLOCK_OPT_SHOW */
+    show_clock(utc);
+    return 0;
+}

branches/2.2.5/mindi-busybox/util-linux/ipcrm.c

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /*
- * ipcrm.c -- utility to allow removal of IPC objects and data structures.
+ * ipcrm.c - utility to allow removal of IPC objects and data structures.
  *
  * 01 Sept 2004 - Rodney Radford <rradford@mindspring.com>
  * Adapted for busybox from util-linux-2.12a.
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
- * --- Pre-busybox history from util-linux-2.12a ------------------------
- *
- * 1999-04-02 frank zago
- * - can now remove several id's in the same call
- *
- * 1999-02-22 Arkadiusz Miÿkiewicz <misiek@pld.ORG.PL>
- * - added Native Language Support
- *
- * Original author - krishna balasubramanian 1993
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-
-#include <sys/types.h>
+#include "libbb.h"
+
+/* X/OPEN tells us to use <sys/{types,ipc,sem}.h> for semctl() */
+/* X/OPEN tells us to use <sys/{types,ipc,msg}.h> for msgctl() */
 #include <sys/ipc.h>
 #include <sys/shm.h>
@@ -41 +18 @@
 #include <sys/sem.h>
 
-/* X/OPEN tells us to use <sys/{types,ipc,sem}.h> for semctl() */
-/* X/OPEN tells us to use <sys/{types,ipc,msg}.h> for msgctl() */
-/* for getopt */
-#include <unistd.h>
-
-/* for tolower and isupper */
-#include <ctype.h>
-
-#include "busybox.h"
-
-#if defined (__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
+#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
 /* union semun is defined by including <sys/sem.h> */
 #else
@@ -63 +30 @@
 #endif
 
+#define IPCRM_LEGACY 1
+
+
+#if IPCRM_LEGACY
+
 typedef enum type_id {
     SHM,
@@ -69 +41 @@
 } type_id;
 
-static int
-remove_ids(type_id type, int argc, char **argv) {
-    int id;
-    int ret = 0;        /* for gcc */
-    char *end;
+static int remove_ids(type_id type, int argc, char **argv)
+{
+    unsigned long id;
+    int ret = 0;        /* silence gcc */
     int nb_errors = 0;
     union semun arg;
@@ -79 +50 @@
     arg.val = 0;
 
-    while(argc) {
-
-        id = strtoul(argv[0], &end, 10);
-
-        if (*end != 0) {
-            bb_printf ("invalid id: %s\n", argv[0]);
-            nb_errors ++;
+    while (argc) {
+        id = bb_strtoul(argv[0], NULL, 10);
+        if (errno || id > INT_MAX) {
+            bb_error_msg("invalid id: %s", argv[0]);
+            nb_errors++;
         } else {
-            switch(type) {
-            case SEM:
-                ret = semctl (id, 0, IPC_RMID, arg);
-                break;
-
-            case MSG:
-                ret = msgctl (id, IPC_RMID, NULL);
-                break;
-
-            case SHM:
-                ret = shmctl (id, IPC_RMID, NULL);
-                break;
-            }
+            if (type == SEM)
+                ret = semctl(id, 0, IPC_RMID, arg);
+            else if (type == MSG)
+                ret = msgctl(id, IPC_RMID, NULL);
+            else if (type ==  SHM)
+                ret = shmctl(id, IPC_RMID, NULL);
 
             if (ret) {
-                bb_printf ("cannot remove id %s (%s)\n",
-                    argv[0], strerror(errno));
-                nb_errors ++;
+                bb_perror_msg("cannot remove id %s", argv[0]);
+                nb_errors++;
             }
         }
@@ -111 +72 @@
     }
 
-    return(nb_errors);
+    return nb_errors;
 }
-
-static int deprecated_main(int argc, char **argv)
-{
-    if (argc < 3) {
-        bb_show_usage();
-        bb_fflush_stdout_and_exit(1);
-    }
-
-    if (!strcmp(argv[1], "shm")) {
-        if (remove_ids(SHM, argc-2, &argv[2]))
-            bb_fflush_stdout_and_exit(1);
-    }
-    else if (!strcmp(argv[1], "msg")) {
-        if (remove_ids(MSG, argc-2, &argv[2]))
-            bb_fflush_stdout_and_exit(1);
-    }
-    else if (!strcmp(argv[1], "sem")) {
-        if (remove_ids(SEM, argc-2, &argv[2]))
-            bb_fflush_stdout_and_exit(1);
-    }
-    else {
-        bb_printf ("unknown resource type: %s\n", argv[1]);
-        bb_show_usage();
-        bb_fflush_stdout_and_exit(1);
-    }
-
-    bb_printf ("resource(s) deleted\n");
-    return 0;
-}
-
-
+#endif /* IPCRM_LEGACY */
+
+
+int ipcrm_main(int argc, char **argv);
 int ipcrm_main(int argc, char **argv)
 {
-    int   c;
-    int   error = 0;
-    char *prog = argv[0];
+    int c;
+    int error = 0;
 
     /* if the command is executed without parameters, do nothing */
     if (argc == 1)
         return 0;
-
+#if IPCRM_LEGACY
     /* check to see if the command is being invoked in the old way if so
-       then run the old code */
-    if (strcmp(argv[1], "shm") == 0 ||
-        strcmp(argv[1], "msg") == 0 ||
-        strcmp(argv[1], "sem") == 0)
-        return deprecated_main(argc, argv);
+       then run the old code. Valid commands are msg, shm, sem. */
+    {
+        type_id what = 0; /* silence gcc */
+        char w;
+
+        w=argv[1][0];
+        if ( ((w == 'm' && argv[1][1] == 's' && argv[1][2] == 'g')
+               || (argv[1][0] == 's'
+                   && ((w=argv[1][1]) == 'h' || w == 'e')
+                   && argv[1][2] == 'm')
+             ) && argv[1][3] == '\0'
+        ) {
+
+            if (argc < 3)
+                bb_show_usage();
+
+            if (w == 'h')
+                what = SHM;
+            else if (w == 'm')
+                what = MSG;
+            else if (w == 'e')
+                what = SEM;
+
+            if (remove_ids(what, argc-2, &argv[2]))
+                fflush_stdout_and_exit(1);
+            printf("resource(s) deleted\n");
+            return 0;
+        }
+    }
+#endif /* IPCRM_LEGACY */
 
     /* process new syntax to conform with SYSV ipcrm */
@@ -165 +123 @@
         int result;
         int id = 0;
-        int iskey = isupper(c);
+        int iskey = (isupper)(c);
 
         /* needed to delete semaphores */
         union semun arg;
+
         arg.val = 0;
 
-        if ((c == '?') || (c == 'h'))
-        {
+        if ((c == '?') || (c == 'h')) {
             bb_show_usage();
-            return 0;
         }
 
@@ -180 +137 @@
         c = tolower(c);
 
-        /* make sure the option is in range */
+        /* make sure the option is in range: allowed are q, m, s */
         if (c != 'q' && c != 'm' && c != 's') {
             bb_show_usage();
-            error++;
-            return error;
         }
 
         if (iskey) {
             /* keys are in hex or decimal */
-            key_t key = strtoul(optarg, NULL, 0);
+            key_t key = xstrtoul(optarg, 0);
+
             if (key == IPC_PRIVATE) {
                 error++;
-                bb_fprintf(stderr, "%s: illegal key (%s)\n",
-                    prog, optarg);
+                bb_error_msg("illegal key (%s)", optarg);
                 continue;
             }
@@ -199 +154 @@
             /* convert key to id */
             id = ((c == 'q') ? msgget(key, 0) :
-                  (c == 'm') ? shmget(key, 0, 0) :
-                  semget(key, 0, 0));
+                  (c == 'm') ? shmget(key, 0, 0) : semget(key, 0, 0));
 
             if (id < 0) {
-                char *errmsg;
+                const char *errmsg;
+
                 error++;
-                switch(errno) {
+                switch (errno) {
                 case EACCES:
-                    errmsg = "permission denied for key";
+                    errmsg = "permission denied for";
                     break;
                 case EIDRM:
-                    errmsg = "already removed key";
+                    errmsg = "already removed";
                     break;
                 case ENOENT:
-                    errmsg = "invalid key";
+                    errmsg = "invalid";
                     break;
                 default:
-                    errmsg = "unknown error in key";
+                    errmsg = "unknown error in";
                     break;
                 }
-                bb_fprintf(stderr, "%s: %s (%s)\n",
-                    prog, errmsg, optarg);
+                bb_error_msg("%s %s (%s)", errmsg, "key", optarg);
                 continue;
             }
         } else {
             /* ids are in decimal */
-            id = strtoul(optarg, NULL, 10);
+            id = xatoul(optarg);
         }
 
         result = ((c == 'q') ? msgctl(id, IPC_RMID, NULL) :
-              (c == 'm') ? shmctl(id, IPC_RMID, NULL) :
-              semctl(id, 0, IPC_RMID, arg));
-
-        if (result < 0) {
-            char *errmsg;
+                  (c == 'm') ? shmctl(id, IPC_RMID, NULL) :
+                  semctl(id, 0, IPC_RMID, arg));
+
+        if (result) {
+            const char *errmsg;
+            const char *const what = iskey ? "key" : "id";
+
             error++;
-            switch(errno) {
+            switch (errno) {
             case EACCES:
             case EPERM:
-                errmsg = iskey
-                    ? "permission denied for key"
-                    : "permission denied for id";
+                errmsg = "permission denied for";
                 break;
             case EINVAL:
-                errmsg = iskey
-                    ? "invalid key"
-                    : "invalid id";
+                errmsg = "invalid";
                 break;
             case EIDRM:
-                errmsg = iskey
-                    ? "already removed key"
-                    : "already removed id";
+                errmsg = "already removed";
                 break;
             default:
-                errmsg = iskey
-                    ? "unknown error in key"
-                    : "unknown error in id";
-                break;
-            }
-            bb_fprintf(stderr, "%s: %s (%s)\n",
-                prog, errmsg, optarg);
+                errmsg = "unknown error in";
+                break;
+            }
+            bb_error_msg("%s %s (%s)", errmsg, what, optarg);
             continue;
         }

branches/2.2.5/mindi-busybox/util-linux/ipcs.c

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /*
  * ipcs.c -- provides information on allocated ipc resources.
@@ -8 +9 @@
  */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <getopt.h>
-#include <errno.h>
-#include <time.h>
-#include <pwd.h>
-#include <grp.h>
-
 /* X/OPEN tells us to use <sys/{types,ipc,sem}.h> for semctl() */
 /* X/OPEN tells us to use <sys/{types,ipc,msg}.h> for msgctl() */
@@ -25 +18 @@
 #include <sys/shm.h>
 
-#include "busybox.h"
+#include "libbb.h"
 
 /*-------------------------------------------------------------------*/
@@ -32 +25 @@
 #ifndef SHM_DEST
 /* shm_mode upper byte flags */
-#define SHM_DEST        01000   /* segment will be destroyed on last detach */
-#define SHM_LOCKED      02000   /* segment will not be swapped */
+#define SHM_DEST        01000   /* segment will be destroyed on last detach */
+#define SHM_LOCKED      02000   /* segment will not be swapped */
 #endif
 
@@ -46 +39 @@
 #define SHM_INFO        14
 struct shm_info {
-     int   used_ids;
-     ulong shm_tot; /* total allocated shm */
-     ulong shm_rss; /* total resident shm */
-     ulong shm_swp; /* total swapped shm */
-     ulong swap_attempts;
-     ulong swap_successes;
+    int used_ids;
+    ulong shm_tot;      /* total allocated shm */
+    ulong shm_rss;      /* total resident shm */
+    ulong shm_swp;      /* total swapped shm */
+    ulong swap_attempts;
+    ulong swap_successes;
 };
 #endif
@@ -69 +62 @@
    X/OPEN tells us to define it ourselves, but until recently
    Linux include files would also define it. */
-#if defined (__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
+#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
 /* union semun is defined by including <sys/sem.h> */
 #else
@@ -86 +79 @@
    glibc-1.09 has no support for sysv ipc.
    glibc 2 uses __key, __seq */
-#if defined (__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1
+#if defined(__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1
 #define KEY __key
 #else
@@ -98 +91 @@
 #define PID 5
 
-
-static void print_perms (int id, struct ipc_perm *ipcp) {
+static char format;
+
+static void print_perms(int id, struct ipc_perm *ipcp)
+{
     struct passwd *pw;
     struct group *gr;
 
-    bb_printf ("%-10d %-10o", id, ipcp->mode & 0777);
+    printf("%-10d %-10o", id, ipcp->mode & 0777);
 
     if ((pw = getpwuid(ipcp->cuid)))
-        bb_printf(" %-10s", pw->pw_name);
+        printf(" %-10s", pw->pw_name);
     else
-        bb_printf(" %-10d", ipcp->cuid);
+        printf(" %-10d", ipcp->cuid);
     if ((gr = getgrgid(ipcp->cgid)))
-        bb_printf(" %-10s", gr->gr_name);
+        printf(" %-10s", gr->gr_name);
     else
-        bb_printf(" %-10d", ipcp->cgid);
+        printf(" %-10d", ipcp->cgid);
 
     if ((pw = getpwuid(ipcp->uid)))
-        bb_printf(" %-10s", pw->pw_name);
+        printf(" %-10s", pw->pw_name);
     else
-        bb_printf(" %-10d", ipcp->uid);
+        printf(" %-10d", ipcp->uid);
     if ((gr = getgrgid(ipcp->gid)))
-        bb_printf(" %-10s\n", gr->gr_name);
+        printf(" %-10s\n", gr->gr_name);
     else
-        bb_printf(" %-10d\n", ipcp->gid);
-}
-
-
-static void do_shm (char format)
+        printf(" %-10d\n", ipcp->gid);
+}
+
+
+static void do_shm(void)
 {
     int maxid, shmid, id;
@@ -134 +129 @@
     struct passwd *pw;
 
-    maxid = shmctl (0, SHM_INFO, (struct shmid_ds *) (void *) &shm_info);
+    maxid = shmctl(0, SHM_INFO, (struct shmid_ds *) (void *) &shm_info);
     if (maxid < 0) {
-        bb_printf ("kernel not configured for shared memory\n");
+        printf("kernel not configured for %s\n", "shared memory");
         return;
     }
@@ -142 +137 @@
     switch (format) {
     case LIMITS:
-        bb_printf ("------ Shared Memory Limits --------\n");
-        if ((shmctl (0, IPC_INFO, (struct shmid_ds *) (void *) &shminfo)) < 0 )
+        printf("------ Shared Memory %s --------\n", "Limits");
+        if ((shmctl(0, IPC_INFO, (struct shmid_ds *) (void *) &shminfo)) < 0)
             return;
         /* glibc 2.1.3 and all earlier libc's have ints as fields
            of struct shminfo; glibc 2.1.91 has unsigned long; ach */
-        bb_printf ("max number of segments = %lu\n"
-            "max seg size (kbytes) = %lu\n"
-            "max total shared memory (pages) = %lu\n"
-            "min seg size (bytes) = %lu\n",
-            (unsigned long) shminfo.shmmni,
-            (unsigned long) (shminfo.shmmax >> 10),
-            (unsigned long) shminfo.shmall,
-            (unsigned long) shminfo.shmmin);
+        printf("max number of segments = %lu\n"
+                  "max seg size (kbytes) = %lu\n"
+                  "max total shared memory (pages) = %lu\n"
+                  "min seg size (bytes) = %lu\n",
+                  (unsigned long) shminfo.shmmni,
+                  (unsigned long) (shminfo.shmmax >> 10),
+                  (unsigned long) shminfo.shmall,
+                  (unsigned long) shminfo.shmmin);
         return;
 
     case STATUS:
-        bb_printf ("------ Shared Memory Status --------\n"
-            "segments allocated %d\n"
-            "pages allocated %ld\n"
-            "pages resident  %ld\n"
-            "pages swapped   %ld\n"
-            "Swap performance: %ld attempts\t %ld successes\n",
-            shm_info.used_ids,
-            shm_info.shm_tot,
-            shm_info.shm_rss,
-            shm_info.shm_swp,
-            shm_info.swap_attempts, shm_info.swap_successes);
+        printf("------ Shared Memory %s --------\n", "Status");
+        printf(   "segments allocated %d\n"
+                  "pages allocated %ld\n"
+                  "pages resident  %ld\n"
+                  "pages swapped   %ld\n"
+                  "Swap performance: %ld attempts\t%ld successes\n",
+                  shm_info.used_ids,
+                  shm_info.shm_tot,
+                  shm_info.shm_rss,
+                  shm_info.shm_swp,
+                  shm_info.swap_attempts, shm_info.swap_successes);
         return;
 
     case CREATOR:
-        bb_printf ("------ Shared Memory Segment Creators/Owners --------\n"
-            "%-10s %-10s %-10s %-10s %-10s %-10s\n",
-            "shmid","perms","cuid","cgid","uid","gid");
+        printf("------ Shared Memory %s --------\n", "Segment Creators/Owners");
+        printf(   "%-10s %-10s %-10s %-10s %-10s %-10s\n",
+                  "shmid", "perms", "cuid", "cgid", "uid", "gid");
         break;
 
     case TIME:
-        bb_printf ("------ Shared Memory Attach/Detach/Change Times --------\n"
-            "%-10s %-10s %-20s %-20s %-20s\n",
-            "shmid","owner","attached","detached","changed");
+        printf("------ Shared Memory %s --------\n", "Attach/Detach/Change Times");
+        printf(   "%-10s %-10s %-20s %-20s %-20s\n",
+                  "shmid", "owner", "attached", "detached", "changed");
         break;
 
     case PID:
-        bb_printf ("------ Shared Memory Creator/Last-op --------\n"
-            "%-10s %-10s %-10s %-10s\n",
-            "shmid","owner","cpid","lpid");
+        printf("------ Shared Memory %s --------\n", "Creator/Last-op");
+        printf(   "%-10s %-10s %-10s %-10s\n",
+                  "shmid", "owner", "cpid", "lpid");
         break;
 
     default:
-        bb_printf ("------ Shared Memory Segments --------\n"
-            "%-10s %-10s %-10s %-10s %-10s %-10s %-12s\n",
-            "key","shmid","owner","perms","bytes","nattch","status");
+        printf("------ Shared Memory %s --------\n", "Segments");
+        printf(   "%-10s %-10s %-10s %-10s %-10s %-10s %-12s\n",
+                  "key", "shmid", "owner", "perms", "bytes", "nattch",
+                  "status");
         break;
     }
 
     for (id = 0; id <= maxid; id++) {
-        shmid = shmctl (id, SHM_STAT, &shmseg);
+        shmid = shmctl(id, SHM_STAT, &shmseg);
         if (shmid < 0)
             continue;
-        if (format == CREATOR)  {
-            print_perms (shmid, ipcp);
+        if (format == CREATOR) {
+            print_perms(shmid, ipcp);
             continue;
         }
@@ -208 +204 @@
         case TIME:
             if (pw)
-                bb_printf ("%-10d %-10.10s", shmid, pw->pw_name);
-            else
-                bb_printf ("%-10d %-10d", shmid, ipcp->uid);
+                printf("%-10d %-10.10s", shmid, pw->pw_name);
+            else
+                printf("%-10d %-10d", shmid, ipcp->uid);
             /* ctime uses static buffer: use separate calls */
-            bb_printf("  %-20.16s", shmseg.shm_atime
-                   ? ctime(&shmseg.shm_atime) + 4 : "Not set");
-            bb_printf(" %-20.16s", shmseg.shm_dtime
-                   ? ctime(&shmseg.shm_dtime) + 4 : "Not set");
-            bb_printf(" %-20.16s\n", shmseg.shm_ctime
-                   ? ctime(&shmseg.shm_ctime) + 4 : "Not set");
+            printf(" %-20.16s", shmseg.shm_atime
+                      ? ctime(&shmseg.shm_atime) + 4 : "Not set");
+            printf(" %-20.16s", shmseg.shm_dtime
+                      ? ctime(&shmseg.shm_dtime) + 4 : "Not set");
+            printf(" %-20.16s\n", shmseg.shm_ctime
+                      ? ctime(&shmseg.shm_ctime) + 4 : "Not set");
             break;
         case PID:
             if (pw)
-                bb_printf ("%-10d %-10.10s", shmid, pw->pw_name);
-            else
-                bb_printf ("%-10d %-10d", shmid, ipcp->uid);
-            bb_printf (" %-10d %-10d\n",
-                shmseg.shm_cpid, shmseg.shm_lpid);
+                printf("%-10d %-10.10s", shmid, pw->pw_name);
+            else
+                printf("%-10d %-10d", shmid, ipcp->uid);
+            printf(" %-10d %-10d\n", shmseg.shm_cpid, shmseg.shm_lpid);
             break;
 
         default:
-                bb_printf("0x%08x ",ipcp->KEY );
-            if (pw)
-                bb_printf ("%-10d %-10.10s", shmid, pw->pw_name);
-            else
-                bb_printf ("%-10d %-10d", shmid, ipcp->uid);
-            bb_printf ("%-10o %-10lu %-10ld %-6s %-6s\n",
-                ipcp->mode & 0777,
-                /*
-                 * earlier: int, Austin has size_t
-                 */
-                (unsigned long) shmseg.shm_segsz,
-                /*
-                 * glibc-2.1.3 and earlier has unsigned short;
-                 * Austin has shmatt_t
-                 */
-                (long) shmseg.shm_nattch,
-                ipcp->mode & SHM_DEST ? "dest" : " ",
-                ipcp->mode & SHM_LOCKED ? "locked" : " ");
-            break;
-        }
-    }
-    return;
-}
-
-
-static void do_sem (char format)
+            printf("0x%08x ", ipcp->KEY);
+            if (pw)
+                printf("%-10d %-10.10s", shmid, pw->pw_name);
+            else
+                printf("%-10d %-10d", shmid, ipcp->uid);
+            printf(" %-10o %-10lu %-10ld %-6s %-6s\n", ipcp->mode & 0777,
+                      /*
+                       * earlier: int, Austin has size_t
+                       */
+                      (unsigned long) shmseg.shm_segsz,
+                      /*
+                       * glibc-2.1.3 and earlier has unsigned short;
+                       * Austin has shmatt_t
+                       */
+                      (long) shmseg.shm_nattch,
+                      ipcp->mode & SHM_DEST ? "dest" : " ",
+                      ipcp->mode & SHM_LOCKED ? "locked" : " ");
+            break;
+        }
+    }
+}
+
+
+static void do_sem(void)
 {
     int maxid, semid, id;
@@ -263 +256 @@
     union semun arg;
 
-    arg.array = (ushort *)  (void *) &seminfo;
-    maxid = semctl (0, 0, SEM_INFO, arg);
+    arg.array = (ushort *) (void *) &seminfo;
+    maxid = semctl(0, 0, SEM_INFO, arg);
     if (maxid < 0) {
-        bb_printf ("kernel not configured for semaphores\n");
+        printf("kernel not configured for %s\n", "semaphores");
         return;
     }
@@ -272 +265 @@
     switch (format) {
     case LIMITS:
-        bb_printf ("------ Semaphore Limits --------\n");
-        arg.array = (ushort *) (void *) &seminfo; /* damn union */
-        if ((semctl (0, 0, IPC_INFO, arg)) < 0 )
+        printf("------ Semaphore %s --------\n", "Limits");
+        arg.array = (ushort *) (void *) &seminfo;   /* damn union */
+        if ((semctl(0, 0, IPC_INFO, arg)) < 0)
             return;
-        bb_printf ("max number of arrays = %d\n"
-            "max semaphores per array = %d\n"
-            "max semaphores system wide = %d\n"
-            "max ops per semop call = %d\n"
-            "semaphore max value = %d\n",
-            seminfo.semmni,
-            seminfo.semmsl,
-            seminfo.semmns,
-            seminfo.semopm,
-            seminfo.semvmx);
+        printf("max number of arrays = %d\n"
+                  "max semaphores per array = %d\n"
+                  "max semaphores system wide = %d\n"
+                  "max ops per semop call = %d\n"
+                  "semaphore max value = %d\n",
+                  seminfo.semmni,
+                  seminfo.semmsl,
+                  seminfo.semmns, seminfo.semopm, seminfo.semvmx);
         return;
 
     case STATUS:
-        bb_printf ("------ Semaphore Status --------\n"
-            "used arrays = %d\n"
-            "allocated semaphores = %d\n",
-            seminfo.semusz,
-            seminfo.semaem);
+        printf("------ Semaphore %s --------\n", "Status");
+        printf(   "used arrays = %d\n"
+                  "allocated semaphores = %d\n",
+                  seminfo.semusz, seminfo.semaem);
         return;
 
     case CREATOR:
-        bb_printf ("------ Semaphore Arrays Creators/Owners --------\n"
-            "%-10s %-10s %-10s %-10s %-10s %-10s\n",
-            "semid","perms","cuid","cgid","uid","gid");
+        printf("------ Semaphore %s --------\n", "Arrays Creators/Owners");
+        printf(   "%-10s %-10s %-10s %-10s %-10s %-10s\n",
+                  "semid", "perms", "cuid", "cgid", "uid", "gid");
         break;
 
     case TIME:
-        bb_printf ("------ Shared Memory Operation/Change Times --------\n"
-            "%-8s %-10s %-26.24s %-26.24s\n",
-            "shmid","owner","last-op","last-changed");
+        printf("------ Shared Memory %s --------\n", "Operation/Change Times");
+        printf(   "%-8s %-10s %-26.24s %-26.24s\n",
+                  "shmid", "owner", "last-op", "last-changed");
         break;
 
@@ -312 +302 @@
 
     default:
-        bb_printf ("------ Semaphore Arrays --------\n"
-            "%-10s %-10s %-10s %-10s %-10s\n",
-            "key","semid","owner","perms","nsems");
+        printf("------ Semaphore %s --------\n", "Arrays");
+        printf(   "%-10s %-10s %-10s %-10s %-10s\n",
+                  "key", "semid", "owner", "perms", "nsems");
         break;
     }
@@ -320 +310 @@
     for (id = 0; id <= maxid; id++) {
         arg.buf = (struct semid_ds *) &semary;
-        semid = semctl (id, 0, SEM_STAT, arg);
+        semid = semctl(id, 0, SEM_STAT, arg);
         if (semid < 0)
             continue;
-        if (format == CREATOR)  {
-            print_perms (semid, ipcp);
+        if (format == CREATOR) {
+            print_perms(semid, ipcp);
             continue;
         }
@@ -331 +321 @@
         case TIME:
             if (pw)
-                bb_printf ("%-8d %-10.10s", semid, pw->pw_name);
-            else
-                bb_printf ("%-8d %-10d", semid, ipcp->uid);
-            bb_printf ("  %-26.24s", semary.sem_otime
-                ? ctime(&semary.sem_otime) : "Not set");
-            bb_printf (" %-26.24s\n", semary.sem_ctime
-                ? ctime(&semary.sem_ctime) : "Not set");
+                printf("%-8d %-10.10s", semid, pw->pw_name);
+            else
+                printf("%-8d %-10d", semid, ipcp->uid);
+            /* ctime uses static buffer: use separate calls */
+            printf("  %-26.24s", semary.sem_otime
+                      ? ctime(&semary.sem_otime) : "Not set");
+            printf(" %-26.24s\n", semary.sem_ctime
+                      ? ctime(&semary.sem_ctime) : "Not set");
             break;
         case PID:
@@ -343 +334 @@
 
         default:
-                bb_printf("0x%08x ", ipcp->KEY);
-            if (pw)
-                bb_printf ("%-10d %-10.9s", semid, pw->pw_name);
-            else
-                bb_printf ("%-10d %-9d", semid, ipcp->uid);
-                    bb_printf ("%-10o %-10ld\n",
-                ipcp->mode & 0777,
-                /*
-                 * glibc-2.1.3 and earlier has unsigned short;
-                 * glibc-2.1.91 has variation between
-                 * unsigned short and unsigned long
-                 * Austin prescribes unsigned short.
-                 */
-                (long) semary.sem_nsems);
-            break;
-        }
-    }
-}
-
-
-static void do_msg (char format)
+            printf("0x%08x ", ipcp->KEY);
+            if (pw)
+                printf("%-10d %-10.9s", semid, pw->pw_name);
+            else
+                printf("%-10d %-9d", semid, ipcp->uid);
+            printf(" %-10o %-10ld\n", ipcp->mode & 0777,
+                      /*
+                       * glibc-2.1.3 and earlier has unsigned short;
+                       * glibc-2.1.91 has variation between
+                       * unsigned short and unsigned long
+                       * Austin prescribes unsigned short.
+                       */
+                      (long) semary.sem_nsems);
+            break;
+        }
+    }
+}
+
+
+static void do_msg(void)
 {
     int maxid, msqid, id;
@@ -371 +361 @@
     struct passwd *pw;
 
-    maxid = msgctl (0, MSG_INFO, (struct msqid_ds *) (void *) &msginfo);
+    maxid = msgctl(0, MSG_INFO, (struct msqid_ds *) (void *) &msginfo);
     if (maxid < 0) {
-        bb_printf ("kernel not configured for message queues\n");
+        printf("kernel not configured for %s\n", "message queues");
         return;
     }
@@ -379 +369 @@
     switch (format) {
     case LIMITS:
-        if ((msgctl (0, IPC_INFO, (struct msqid_ds *) (void *) &msginfo)) < 0 )
+        if ((msgctl(0, IPC_INFO, (struct msqid_ds *) (void *) &msginfo)) < 0)
             return;
-        bb_printf ("------ Messages: Limits --------\n"
-            "max queues system wide = %d\n"
-            "max size of message (bytes) = %d\n"
-            "default max size of queue (bytes) = %d\n",
-            msginfo.msgmni,
-            msginfo.msgmax,
-            msginfo.msgmnb);
+        printf("------ Message%s --------\n", "s: Limits");
+        printf(   "max queues system wide = %d\n"
+                  "max size of message (bytes) = %d\n"
+                  "default max size of queue (bytes) = %d\n",
+                  msginfo.msgmni, msginfo.msgmax, msginfo.msgmnb);
         return;
 
     case STATUS:
-        bb_printf ("------ Messages: Status --------\n"
-            "allocated queues = %d\n"
-            "used headers = %d\n"
-            "used space = %d bytes\n",
-            msginfo.msgpool,
-            msginfo.msgmap,
-            msginfo.msgtql);
+        printf("------ Message%s --------\n", "s: Status");
+        printf(   "allocated queues = %d\n"
+                  "used headers = %d\n"
+                  "used space = %d bytes\n",
+                  msginfo.msgpool, msginfo.msgmap, msginfo.msgtql);
         return;
 
     case CREATOR:
-        bb_printf ("------ Message Queues: Creators/Owners --------\n"
-            "%-10s %-10s %-10s %-10s %-10s %-10s\n",
-            "msqid","perms","cuid","cgid","uid","gid");
+        printf("------ Message%s --------\n", " Queues: Creators/Owners");
+        printf(   "%-10s %-10s %-10s %-10s %-10s %-10s\n",
+                  "msqid", "perms", "cuid", "cgid", "uid", "gid");
         break;
 
     case TIME:
-        bb_printf ("------ Message Queues Send/Recv/Change Times --------\n"
-            "%-8s %-10s %-20s %-20s %-20s\n",
-            "msqid","owner","send","recv","change");
+        printf("------ Message%s --------\n", " Queues Send/Recv/Change Times");
+        printf(   "%-8s %-10s %-20s %-20s %-20s\n",
+                  "msqid", "owner", "send", "recv", "change");
         break;
 
     case PID:
-        bb_printf ("------ Message Queues PIDs --------\n"
-            "%-10s %-10s %-10s %-10s\n",
-            "msqid","owner","lspid","lrpid");
+        printf("------ Message%s --------\n", " Queues PIDs");
+        printf(   "%-10s %-10s %-10s %-10s\n",
+                  "msqid", "owner", "lspid", "lrpid");
         break;
 
     default:
-        bb_printf ("------ Message Queues --------\n"
-            "%-10s %-10s %-10s %-10s %-12s %-12s\n",
-            "key","msqid","owner","perms","used-bytes","messages");
+        printf("------ Message%s --------\n", " Queues");
+        printf(   "%-10s %-10s %-10s %-10s %-12s %-12s\n",
+                  "key", "msqid", "owner", "perms", "used-bytes", "messages");
         break;
     }
 
     for (id = 0; id <= maxid; id++) {
-        msqid = msgctl (id, MSG_STAT, &msgque);
+        msqid = msgctl(id, MSG_STAT, &msgque);
         if (msqid < 0)
             continue;
-        if (format == CREATOR)  {
-            print_perms (msqid, ipcp);
+        if (format == CREATOR) {
+            print_perms(msqid, ipcp);
             continue;
         }
@@ -437 +423 @@
         case TIME:
             if (pw)
-                bb_printf ("%-8d %-10.10s", msqid, pw->pw_name);
-            else
-                bb_printf ("%-8d %-10d", msqid, ipcp->uid);
-            bb_printf (" %-20.16s", msgque.msg_stime
-                ? ctime(&msgque.msg_stime) + 4 : "Not set");
-            bb_printf (" %-20.16s", msgque.msg_rtime
-                ? ctime(&msgque.msg_rtime) + 4 : "Not set");
-            bb_printf (" %-20.16s\n", msgque.msg_ctime
-                ? ctime(&msgque.msg_ctime) + 4 : "Not set");
+                printf("%-8d %-10.10s", msqid, pw->pw_name);
+            else
+                printf("%-8d %-10d", msqid, ipcp->uid);
+            printf(" %-20.16s", msgque.msg_stime
+                      ? ctime(&msgque.msg_stime) + 4 : "Not set");
+            printf(" %-20.16s", msgque.msg_rtime
+                      ? ctime(&msgque.msg_rtime) + 4 : "Not set");
+            printf(" %-20.16s\n", msgque.msg_ctime
+                      ? ctime(&msgque.msg_ctime) + 4 : "Not set");
             break;
         case PID:
             if (pw)
-                bb_printf ("%-8d %-10.10s", msqid, pw->pw_name);
-            else
-                bb_printf ("%-8d %-10d", msqid, ipcp->uid);
-            bb_printf ("  %5d     %5d\n",
-                msgque.msg_lspid, msgque.msg_lrpid);
+                printf("%-8d %-10.10s", msqid, pw->pw_name);
+            else
+                printf("%-8d %-10d", msqid, ipcp->uid);
+            printf("  %5d     %5d\n", msgque.msg_lspid, msgque.msg_lrpid);
             break;
 
         default:
-                bb_printf( "0x%08x ",ipcp->KEY );
-            if (pw)
-                bb_printf ("%-10d %-10.10s", msqid, pw->pw_name);
-            else
-                bb_printf ("%-10d %-10d", msqid, ipcp->uid);
-                    bb_printf (" %-10o %-12ld %-12ld\n",
-                ipcp->mode & 0777,
-                /*
-                 * glibc-2.1.3 and earlier has unsigned short;
-                 * glibc-2.1.91 has variation between
-                 * unsigned short, unsigned long
-                 * Austin has msgqnum_t
-                 */
-                (long) msgque.msg_cbytes,
-                (long) msgque.msg_qnum);
-            break;
-        }
-    }
-    return;
-}
-
-
-static void print_shm (int shmid)
+            printf("0x%08x ", ipcp->KEY);
+            if (pw)
+                printf("%-10d %-10.10s", msqid, pw->pw_name);
+            else
+                printf("%-10d %-10d", msqid, ipcp->uid);
+            printf(" %-10o %-12ld %-12ld\n", ipcp->mode & 0777,
+                      /*
+                       * glibc-2.1.3 and earlier has unsigned short;
+                       * glibc-2.1.91 has variation between
+                       * unsigned short, unsigned long
+                       * Austin has msgqnum_t
+                       */
+                      (long) msgque.msg_cbytes, (long) msgque.msg_qnum);
+            break;
+        }
+    }
+}
+
+
+static void print_shm(int shmid)
 {
     struct shmid_ds shmds;
     struct ipc_perm *ipcp = &shmds.shm_perm;
 
-    if (shmctl (shmid, IPC_STAT, &shmds) == -1) {
-        perror ("shmctl ");
-        return;
-    }
-
-    bb_printf ("\nShared memory Segment shmid=%d\n"
-        "uid=%d\tgid=%d\tcuid=%d\tcgid=%d\n"
-        "mode=%#o\taccess_perms=%#o\n"
-        "bytes=%ld\tlpid=%d\tcpid=%d\tnattch=%ld\n"
-        "att_time=%-26.24s\n"
-        "det_time=%-26.24s\n"
-        "change_time=%-26.24s\n"
-        "\n",
-        shmid,
-        ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid,
-        ipcp->mode, ipcp->mode & 0777,
-        (long) shmds.shm_segsz, shmds.shm_lpid, shmds.shm_cpid,
-        (long) shmds.shm_nattch,
-        shmds.shm_atime ? ctime (&shmds.shm_atime) : "Not set",
-        shmds.shm_dtime ? ctime (&shmds.shm_dtime) : "Not set",
-        ctime (&shmds.shm_ctime));
-    return;
-}
-
-
-static void print_msg (int msqid)
+    if (shmctl(shmid, IPC_STAT, &shmds) == -1) {
+        bb_perror_msg("shmctl");
+        return;
+    }
+
+    printf("\nShared memory Segment shmid=%d\n"
+              "uid=%d\tgid=%d\tcuid=%d\tcgid=%d\n"
+              "mode=%#o\taccess_perms=%#o\n"
+              "bytes=%ld\tlpid=%d\tcpid=%d\tnattch=%ld\n",
+              shmid,
+              ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid,
+              ipcp->mode, ipcp->mode & 0777,
+              (long) shmds.shm_segsz, shmds.shm_lpid, shmds.shm_cpid,
+              (long) shmds.shm_nattch);
+    printf("att_time=%-26.24s\n",
+              shmds.shm_atime ? ctime(&shmds.shm_atime) : "Not set");
+    printf("det_time=%-26.24s\n",
+              shmds.shm_dtime ? ctime(&shmds.shm_dtime) : "Not set");
+    printf("change_time=%-26.24s\n\n", ctime(&shmds.shm_ctime));
+}
+
+
+static void print_msg(int msqid)
 {
     struct msqid_ds buf;
     struct ipc_perm *ipcp = &buf.msg_perm;
 
-    if (msgctl (msqid, IPC_STAT, &buf) == -1) {
-        perror ("msgctl ");
-        return;
-    }
-
-    bb_printf ("\nMessage Queue msqid=%d\n"
-        "uid=%d\tgid=%d\tcuid=%d\tcgid=%d\tmode=%#o\n"
-        "cbytes=%ld\tqbytes=%ld\tqnum=%ld\tlspid=%d\tlrpid=%d\n"
-        "send_time=%-26.24s\n"
-        "rcv_time=%-26.24s\n"
-        "change_time=%-26.24s\n"
-        "\n",
-        msqid,
-        ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid, ipcp->mode,
-        /*
-         * glibc-2.1.3 and earlier has unsigned short;
-         * glibc-2.1.91 has variation between
-         * unsigned short, unsigned long
-         * Austin has msgqnum_t (for msg_qbytes)
-         */
-        (long) buf.msg_cbytes, (long) buf.msg_qbytes,
-        (long) buf.msg_qnum, buf.msg_lspid, buf.msg_lrpid,
-        buf.msg_stime ? ctime (&buf.msg_stime) : "Not set",
-        buf.msg_rtime ? ctime (&buf.msg_rtime) : "Not set",
-        buf.msg_ctime ? ctime (&buf.msg_ctime) : "Not set");
-    return;
-}
-
-static void print_sem (int semid)
+    if (msgctl(msqid, IPC_STAT, &buf) == -1) {
+        bb_perror_msg("msgctl");
+        return;
+    }
+
+    printf("\nMessage Queue msqid=%d\n"
+              "uid=%d\tgid=%d\tcuid=%d\tcgid=%d\tmode=%#o\n"
+              "cbytes=%ld\tqbytes=%ld\tqnum=%ld\tlspid=%d\tlrpid=%d\n",
+              msqid, ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid, ipcp->mode,
+              /*
+               * glibc-2.1.3 and earlier has unsigned short;
+               * glibc-2.1.91 has variation between
+               * unsigned short, unsigned long
+               * Austin has msgqnum_t (for msg_qbytes)
+               */
+              (long) buf.msg_cbytes, (long) buf.msg_qbytes,
+              (long) buf.msg_qnum, buf.msg_lspid, buf.msg_lrpid);
+
+    printf("send_time=%-26.24s\n",
+              buf.msg_stime ? ctime(&buf.msg_stime) : "Not set");
+    printf("rcv_time=%-26.24s\n",
+              buf.msg_rtime ? ctime(&buf.msg_rtime) : "Not set");
+    printf("change_time=%-26.24s\n\n",
+              buf.msg_ctime ? ctime(&buf.msg_ctime) : "Not set");
+}
+
+static void print_sem(int semid)
 {
     struct semid_ds semds;
@@ -550 +527 @@
 
     arg.buf = &semds;
-    if (semctl (semid, 0, IPC_STAT, arg) < 0) {
-        perror ("semctl ");
-        return;
-    }
-
-    bb_printf ("\nSemaphore Array semid=%d\n"
-        "uid=%d\t gid=%d\t cuid=%d\t cgid=%d\n"
-        "mode=%#o, access_perms=%#o\n"
-        "nsems = %ld\n"
-        "otime = %-26.24s\n"
-        "ctime = %-26.24s\n"
-        "%-10s %-10s %-10s %-10s %-10s\n",
-        semid,
-        ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid,
-        ipcp->mode, ipcp->mode & 0777,
-        (long) semds.sem_nsems,
-        semds.sem_otime ? ctime (&semds.sem_otime) : "Not set",
-        ctime (&semds.sem_ctime),
-        "semnum","value","ncount","zcount","pid");
+    if (semctl(semid, 0, IPC_STAT, arg)) {
+        bb_perror_msg("semctl");
+        return;
+    }
+
+    printf("\nSemaphore Array semid=%d\n"
+              "uid=%d\t gid=%d\t cuid=%d\t cgid=%d\n"
+              "mode=%#o, access_perms=%#o\n"
+              "nsems = %ld\n"
+              "otime = %-26.24s\n",
+              semid,
+              ipcp->uid, ipcp->gid, ipcp->cuid, ipcp->cgid,
+              ipcp->mode, ipcp->mode & 0777,
+              (long) semds.sem_nsems,
+              semds.sem_otime ? ctime(&semds.sem_otime) : "Not set");
+    printf("ctime = %-26.24s\n"
+              "%-10s %-10s %-10s %-10s %-10s\n",
+              ctime(&semds.sem_ctime),
+              "semnum", "value", "ncount", "zcount", "pid");
 
     arg.val = 0;
-    for (i=0; i < semds.sem_nsems; i++) {
+    for (i = 0; i < semds.sem_nsems; i++) {
         int val, ncnt, zcnt, pid;
-        val = semctl (semid, i, GETVAL, arg);
-        ncnt = semctl (semid, i, GETNCNT, arg);
-        zcnt = semctl (semid, i, GETZCNT, arg);
-        pid = semctl (semid, i, GETPID, arg);
+
+        val = semctl(semid, i, GETVAL, arg);
+        ncnt = semctl(semid, i, GETNCNT, arg);
+        zcnt = semctl(semid, i, GETZCNT, arg);
+        pid = semctl(semid, i, GETPID, arg);
         if (val < 0 || ncnt < 0 || zcnt < 0 || pid < 0) {
-            perror ("semctl ");
-            bb_fflush_stdout_and_exit (1);
-        }
-        bb_printf ("%-10d %-10d %-10d %-10d %-10d\n",
-            i, val, ncnt, zcnt, pid);
-    }
-    bb_printf ("\n");
-    return;
-}
-
-int ipcs_main (int argc, char **argv) {
-    int opt, msg = 0, sem = 0, shm = 0, id=0, print=0;
-    char format = 0;
-    char options[] = "atclupsmqi:ih?";
-
-    while ((opt = getopt (argc, argv, options)) != -1) {
-        switch (opt) {
-        case 'i':
-            id = atoi (optarg);
-            print = 1;
-            break;
-        case 'a':
-            msg = shm = sem = 1;
-            break;
-        case 'q':
-            msg = 1;
-            break;
-        case 's':
-            sem = 1;
-            break;
-        case 'm':
-            shm = 1;
-            break;
-        case 't':
-            format = TIME;
-            break;
-        case 'c':
-            format = CREATOR;
-            break;
-        case 'p':
-            format = PID;
-            break;
-        case 'l':
-            format = LIMITS;
-            break;
-        case 'u':
-            format = STATUS;
-            break;
-        case 'h':
-        case '?':
-            bb_show_usage();
-            bb_fflush_stdout_and_exit (0);
-        }
-    }
-
-    if  (print) {
-        if (shm) {
-            print_shm (id);
-            bb_fflush_stdout_and_exit (0);
-        }
-        if (sem) {
-            print_sem (id);
-            bb_fflush_stdout_and_exit (0);
-        }
-        if (msg) {
-            print_msg (id);
-            bb_fflush_stdout_and_exit (0);
+            bb_perror_msg_and_die("semctl");
+        }
+        printf("%-10d %-10d %-10d %-10d %-10d\n", i, val, ncnt, zcnt, pid);
+    }
+    puts("");
+}
+
+int ipcs_main(int argc, char **argv);
+int ipcs_main(int argc, char **argv)
+{
+    int id = 0;
+    unsigned flags = 0;
+    unsigned opt;
+    char *opt_i;
+#define flag_print  (1<<0)
+#define flag_msg    (1<<1)
+#define flag_sem    (1<<2)
+#define flag_shm    (1<<3)
+
+    opt = getopt32(argv, "i:aqsmtcplu", &opt_i);
+    if (opt & 0x1) { // -i
+        id = xatoi(opt_i);
+        flags |= flag_print;
+    }
+    if (opt & 0x2) flags |= flag_msg | flag_sem | flag_shm; // -a
+    if (opt & 0x4) flags |= flag_msg; // -q
+    if (opt & 0x8) flags |= flag_sem; // -s
+    if (opt & 0x10) flags |= flag_shm; // -m
+    if (opt & 0x20) format = TIME; // -t
+    if (opt & 0x40) format = CREATOR; // -c
+    if (opt & 0x80) format = PID; // -p
+    if (opt & 0x100) format = LIMITS; // -l
+    if (opt & 0x200) format = STATUS; // -u
+
+    if (flags & flag_print) {
+        if (flags & flag_shm) {
+            print_shm(id);
+            fflush_stdout_and_exit(0);
+        }
+        if (flags & flag_sem) {
+            print_sem(id);
+            fflush_stdout_and_exit(0);
+        }
+        if (flags & flag_msg) {
+            print_msg(id);
+            fflush_stdout_and_exit(0);
         }
         bb_show_usage();
-        bb_fflush_stdout_and_exit (0);
-    }
-
-    if ( !shm && !msg && !sem)
-        msg = sem = shm = 1;
-    bb_printf ("\n");
-
-    if (shm) {
-        do_shm (format);
-        bb_printf ("\n");
-    }
-    if (sem) {
-        do_sem (format);
-        bb_printf ("\n");
-    }
-    if (msg) {
-        do_msg (format);
-        bb_printf ("\n");
-    }
-    return 0;
-}
-
+    }
+
+    if (!(flags & (flag_shm | flag_msg | flag_sem)))
+        flags |= flag_msg | flag_shm | flag_sem;
+    puts("");
+
+    if (flags & flag_shm) {
+        do_shm();
+        puts("");
+    }
+    if (flags & flag_sem) {
+        do_sem();
+        puts("");
+    }
+    if (flags & flag_msg) {
+        do_msg();
+        puts("");
+    }
+    fflush_stdout_and_exit(0);
+}

branches/2.2.5/mindi-busybox/util-linux/losetup.c

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /*
  * Mini losetup implementation for busybox
@@ -8 +9 @@
 
 #include <getopt.h>
-#include <stdlib.h>
 
-#include "busybox.h"
+#include "libbb.h"
 
-int losetup_main (int argc, char **argv)
+int losetup_main(int argc, char **argv);
+int losetup_main(int argc, char **argv)
 {
-  int offset = 0;
+    unsigned opt;
+    char *opt_o;
+    unsigned long long offset = 0;
 
-  /* This will need a "while(getopt()!=-1)" loop when we can have more than
-     one option, but for now we can't. */
-  switch(getopt(argc,argv, "do:")) {
-    case 'd':
-      /* detach takes exactly one argument */
-      if(optind+1!=argc) bb_show_usage();
-      if(!del_loop(argv[optind])) return EXIT_SUCCESS;
-die_failed:
-      bb_perror_msg_and_die("%s",argv[optind]);
+    opt = getopt32(argv, "do:", &opt_o);
+    argc -= optind;
+    argv += optind;
 
-    case 'o':
-      offset = bb_xparse_number (optarg, NULL);
-      /* Fall through to do the losetup */
-    case -1:
-      /* losetup takes two argument:, loop_device and file */
-      if(optind+2==argc) {
-    if(set_loop(&argv[optind], argv[optind + 1], offset)>=0)
-      return EXIT_SUCCESS;
-    else goto die_failed;
-      }
-      if(optind+1==argc) {
-    char *s=query_loop(argv[optind]);
-    if (!s) goto die_failed;
-    printf("%s: %s\n",argv[optind],s);
-    if(ENABLE_FEATURE_CLEAN_UP) free(s);
+    if (opt == 0x3) // -d + -o (illegal)
+        bb_show_usage();
+
+    if (opt == 0x1) { // -d
+        /* detach takes exactly one argument */
+        if (argc != 1)
+            bb_show_usage();
+        if (!del_loop(argv[0]))
+            return EXIT_SUCCESS;
+        bb_perror_nomsg_and_die();
+    }
+
+    if (opt == 0x2) // -o
+        offset = xatoull(opt_o);
+
+    /* -o or no option */
+
+    if (argc == 2) {
+        if (set_loop(&argv[0], argv[1], offset) < 0)
+            bb_perror_nomsg_and_die();
+    } else if (argc == 1) {
+        char *s = query_loop(argv[0]);
+        if (!s)
+            bb_perror_nomsg_and_die();
+        printf("%s: %s\n", argv[0], s);
+        if (ENABLE_FEATURE_CLEAN_UP)
+            free(s);
+    } else {
+        char dev[sizeof(LOOP_NAME"0")] = LOOP_NAME"0";
+        char c;
+        for (c = '0'; c <= '9'; ++c) {
+            char *s;
+            dev[sizeof(LOOP_NAME"0")-2] = c;
+            s = query_loop(dev);
+            if (s) {
+                printf("%s: %s\n", dev, s);
+                if (ENABLE_FEATURE_CLEAN_UP)
+                    free(s);
+            }
+        }
+    }
     return EXIT_SUCCESS;
-      }
-      break;
-  }
-  bb_show_usage();
-  return EXIT_FAILURE;
 }

branches/2.2.5/mindi-busybox/util-linux/mdev.c

@@ -1 @@
-/* vi:set ts=4:
+/* vi: set sw=4 ts=4: */
+/*
  *
  * mdev - Mini udev for busybox
@@ -6 +7 @@
  * Copyright 2005 Frank Sorenson <frank@tuxrocks.com>
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPL version 2, see file LICENSE in this tarball for details.
  */
 
-#include "busybox.h"
-#include <ctype.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/sysmacros.h>
+#include "libbb.h"
 #include "xregex.h"
 
-#define DEV_PATH    "/dev"
-
-struct mdev_globals
-{
+struct globals {
     int root_major, root_minor;
-} mdev_globals;
-
-#define bbg mdev_globals
+};
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define root_major (G.root_major)
+#define root_minor (G.root_minor)
+
+#define MAX_SYSFS_DEPTH 3 /* prevent infinite loops in /sys symlinks */
 
 /* mknod in /dev based on a path like "/sys/block/hda/hda1" */
 static void make_device(char *path, int delete)
 {
-    char *device_name;
-    int major, minor, type, len, fd;
+    const char *device_name;
+    int major, minor, type, len;
     int mode = 0660;
     uid_t uid = 0;
@@ -43 +40 @@
     if (!delete) {
         strcat(path, "/dev");
-        fd = open(path, O_RDONLY);
-        len = read(fd, temp + 1, 64);
+        len = open_read_close(path, temp + 1, 64);
         *temp++ = 0;
-        close(fd);
         if (len < 1) return;
     }
@@ -52 +47 @@
     /* Determine device name, type, major and minor */
 
-    device_name = strrchr(path, '/') + 1;
+    device_name = bb_basename(path);
     type = path[5]=='c' ? S_IFCHR : S_IFBLK;
 
@@ -59 +54 @@
     if (ENABLE_FEATURE_MDEV_CONF) {
         char *conf, *pos, *end;
+        int line, fd;
 
         /* mmap the config file */
-        if (-1 != (fd=open("/etc/mdev.conf",O_RDONLY))) {
-            len = lseek(fd, 0, SEEK_END);
-            conf = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
-            if (conf) {
-                int line = 0;
-
-                /* Loop through lines in mmaped file*/
-                for (pos=conf; pos-conf<len;) {
-                    int field;
-                    char *end2;
-
-                    line++;
-                    /* find end of this line */
-                    for(end=pos; end-conf<len && *end!='\n'; end++)
+        fd = open("/etc/mdev.conf", O_RDONLY);
+        if (fd < 0)
+            goto end_parse;
+        len = xlseek(fd, 0, SEEK_END);
+        conf = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
+        close(fd);
+        if (!conf)
+            goto end_parse;
+
+        line = 0;
+        /* Loop through lines in mmaped file*/
+        for (pos=conf; pos-conf<len;) {
+            int field;
+            char *end2;
+
+            line++;
+            /* find end of this line */
+            for (end=pos; end-conf<len && *end!='\n'; end++)
+                ;
+
+            /* Three fields: regex, uid:gid, mode */
+            for (field=0; field < (3 + ENABLE_FEATURE_MDEV_EXEC);
+                    field++)
+            {
+                /* Skip whitespace */
+                while (pos<end && isspace(*pos)) pos++;
+                if (pos==end || *pos=='#') break;
+                for (end2=pos;
+                    end2<end && !isspace(*end2) && *end2!='#'; end2++)
+                    ;
+
+                if (field == 0) {
+                    /* Regex to match this device */
+
+                    char *regex = xstrndup(pos, end2-pos);
+                    regex_t match;
+                    regmatch_t off;
+                    int result;
+
+                    /* Is this it? */
+                    xregcomp(&match,regex, REG_EXTENDED);
+                    result = regexec(&match, device_name, 1, &off, 0);
+                    regfree(&match);
+                    free(regex);
+
+                    /* If not this device, skip rest of line */
+                    if (result || off.rm_so
+                            || off.rm_eo != strlen(device_name))
+                        break;
+                }
+                if (field == 1) {
+                    /* uid:gid */
+
+                    char *s, *s2;
+
+                    /* Find : */
+                    for (s=pos; s<end2 && *s!=':'; s++)
                         ;
-
-                    /* Three fields: regex, uid:gid, mode */
-                    for (field=0; field < (3 + ENABLE_FEATURE_MDEV_EXEC);
-                            field++)
-                    {
-                        /* Skip whitespace */
-                        while (pos<end && isspace(*pos)) pos++;
-                        if (pos==end || *pos=='#') break;
-                        for (end2=pos;
-                            end2<end && !isspace(*end2) && *end2!='#'; end2++)
-                            ;
-
-                        if (!field) {
-                            /* Regex to match this device */
-
-                            char *regex = strndupa(pos, end2-pos);
-                            regex_t match;
-                            regmatch_t off;
-                            int result;
-
-                            /* Is this it? */
-                            xregcomp(&match,regex, REG_EXTENDED);
-                            result = regexec(&match, device_name, 1, &off, 0);
-                            regfree(&match);
-
-                            /* If not this device, skip rest of line */
-                            if (result || off.rm_so
-                                    || off.rm_eo != strlen(device_name))
-                                break;
-
-                        } else if (field == 1) {
-                            /* uid:gid */
-
-                            char *s, *s2;
-
-                            /* Find : */
-                            for(s=pos; s<end2 && *s!=':'; s++)
-                                ;
-                            if (s == end2) break;
-
-                            /* Parse UID */
-                            uid = strtoul(pos,&s2,10);
-                            if (s != s2) {
-                                struct passwd *pass;
-                                pass = getpwnam(strndupa(pos, s-pos));
-                                if (!pass) break;
-                                uid = pass->pw_uid;
-                            }
-                            s++;
-                            /* parse GID */
-                            gid = strtoul(s, &s2, 10);
-                            if (end2 != s2) {
-                                struct group *grp;
-                                grp = getgrnam(strndupa(s, end2-s));
-                                if (!grp) break;
-                                gid = grp->gr_gid;
-                            }
-                        } else if (field == 2) {
-                            /* mode */
-
-                            mode = strtoul(pos, &pos, 8);
-                            if (pos != end2) break;
-                        } else if (ENABLE_FEATURE_MDEV_EXEC && field == 3) {
-                            // Command to run
-                            char *s = "@$*", *s2;
-                            if (!(s2 = strchr(s, *pos++))) {
-                                // Force error
-                                field = 1;
-                                break;
-                            }
-                            if ((s2-s+1) & (1<<delete))
-                                command = bb_xstrndup(pos, end-pos);
-                        }
-
-                        pos = end2;
+                    if (s == end2) break;
+
+                    /* Parse UID */
+                    uid = strtoul(pos, &s2, 10);
+                    if (s != s2) {
+                        struct passwd *pass;
+                        char *_unam = xstrndup(pos, s-pos);
+                        pass = getpwnam(_unam);
+                        free(_unam);
+                        if (!pass) break;
+                        uid = pass->pw_uid;
                     }
-
-                    /* Did everything parse happily? */
-
-                    if (field > 2) break;
-                    if (field) bb_error_msg_and_die("Bad line %d",line);
-
-                    /* Next line */
-                    pos = ++end;
+                    s++;
+                    /* parse GID */
+                    gid = strtoul(s, &s2, 10);
+                    if (end2 != s2) {
+                        struct group *grp;
+                        char *_grnam = xstrndup(s, end2-s);
+                        grp = getgrnam(_grnam);
+                        free(_grnam);
+                        if (!grp) break;
+                        gid = grp->gr_gid;
+                    }
                 }
-                munmap(conf, len);
+                if (field == 2) {
+                    /* mode */
+
+                    mode = strtoul(pos, &pos, 8);
+                    if (pos != end2) break;
+                }
+                if (ENABLE_FEATURE_MDEV_EXEC && field == 3) {
+                    // Command to run
+                    const char *s = "@$*";
+                    const char *s2;
+                    s2 = strchr(s, *pos++);
+                    if (!s2) {
+                        // Force error
+                        field = 1;
+                        break;
+                    }
+                    if ((s2-s+1) & (1<<delete))
+                        command = xstrndup(pos, end-pos);
+                }
+
+                pos = end2;
             }
-            close(fd);
+
+            /* Did everything parse happily? */
+
+            if (field > 2) break;
+            if (field) bb_error_msg_and_die("bad line %d",line);
+
+            /* Next line */
+            pos = ++end;
         }
+        munmap(conf, len);
+ end_parse: /* nothing */ ;
     }
 
@@ -171 +178 @@
         if (sscanf(temp, "%d:%d", &major, &minor) != 2) return;
         if (mknod(device_name, mode | type, makedev(major, minor)) && errno != EEXIST)
-            bb_perror_msg_and_die("mknod %s failed", device_name);
-
-        if (major == bbg.root_major && minor == bbg.root_minor)
+            bb_perror_msg_and_die("mknod %s", device_name);
+
+        if (major == root_major && minor == root_minor)
             symlink(device_name, "root");
-    
+
         if (ENABLE_FEATURE_MDEV_CONF) chown(device_name, uid, gid);
     }
     if (command) {
-        int rc;
-        char *s;
-        
-        s=bb_xasprintf("MDEV=%s",device_name);
+        /* setenv will leak memory, so use putenv */
+        char *s = xasprintf("MDEV=%s", device_name);
         putenv(s);
-        rc = system(command);
-        s[4]=0;
-        putenv(s);
+        if (system(command) == -1)
+            bb_perror_msg_and_die("cannot run %s", command);
+        s[4] = '\0';
+        unsetenv(s);
         free(s);
         free(command);
-        if (rc == -1) bb_perror_msg_and_die("Couldn't run %s", command);
     }
     if (delete) unlink(device_name);
 }
 
-/* Recursive search of /sys/block or /sys/class.  path must be a writeable
- * buffer of size PATH_MAX containing the directory string to start at. */
-
-static void find_dev(char *path)
-{
-    DIR *dir;
-    size_t len = strlen(path);
-    struct dirent *entry;
-
-    if ((dir = opendir(path)) == NULL)
-        return;
-
-    while ((entry = readdir(dir)) != NULL) {
-        struct stat st;
-
-        /* Skip "." and ".." (also skips hidden files, which is ok) */
-
-        if (entry->d_name[0] == '.')
-            continue;
-
-        // uClibc doesn't fill out entry->d_type reliably. so we use lstat().
-
-        snprintf(path+len, PATH_MAX-len, "/%s", entry->d_name);
-        if (!lstat(path, &st) && S_ISDIR(st.st_mode)) find_dev(path);
-        path[len] = 0;
-
-        /* If there's a dev entry, mknod it */
-
-        if (!strcmp(entry->d_name, "dev")) make_device(path, 0);
-    }
-
-    closedir(dir);
-}
-
-int mdev_main(int argc, char *argv[])
+/* File callback for /sys/ traversal */
+static int fileAction(const char *fileName, struct stat *statbuf,
+                      void *userData, int depth)
+{
+    size_t len = strlen(fileName) - 4;
+    char *scratch = userData;
+
+    if (strcmp(fileName + len, "/dev"))
+        return FALSE;
+
+    strcpy(scratch, fileName);
+    scratch[len] = 0;
+    make_device(scratch, 0);
+
+    return TRUE;
+}
+
+/* Directory callback for /sys/ traversal */
+static int dirAction(const char *fileName, struct stat *statbuf,
+                      void *userData, int depth)
+{
+    return (depth >= MAX_SYSFS_DEPTH ? SKIP : TRUE);
+}
+
+/* For the full gory details, see linux/Documentation/firmware_class/README
+ *
+ * Firmware loading works like this:
+ * - kernel sets FIRMWARE env var
+ * - userspace checks /lib/firmware/$FIRMWARE
+ * - userspace waits for /sys/$DEVPATH/loading to appear
+ * - userspace writes "1" to /sys/$DEVPATH/loading
+ * - userspace copies /lib/firmware/$FIRMWARE into /sys/$DEVPATH/data
+ * - userspace writes "0" (worked) or "-1" (failed) to /sys/$DEVPATH/loading
+ * - kernel loads firmware into device
+ */
+static void load_firmware(const char *const firmware, const char *const sysfs_path)
+{
+    int cnt;
+    int firmware_fd, loading_fd, data_fd;
+
+    /* check for $FIRMWARE from kernel */
+    /* XXX: dont bother: open(NULL) works same as open("no-such-file")
+     * if (!firmware)
+     *  return;
+     */
+
+    /* check for /lib/firmware/$FIRMWARE */
+    xchdir("/lib/firmware");
+    firmware_fd = xopen(firmware, O_RDONLY);
+
+    /* in case we goto out ... */
+    data_fd = -1;
+
+    /* check for /sys/$DEVPATH/loading ... give 30 seconds to appear */
+    xchdir(sysfs_path);
+    for (cnt = 0; cnt < 30; ++cnt) {
+        loading_fd = open("loading", O_WRONLY);
+        if (loading_fd == -1)
+            sleep(1);
+        else
+            break;
+    }
+    if (loading_fd == -1)
+        goto out;
+
+    /* tell kernel we're loading by `echo 1 > /sys/$DEVPATH/loading` */
+    if (write(loading_fd, "1", 1) != 1)
+        goto out;
+
+    /* load firmware by `cat /lib/firmware/$FIRMWARE > /sys/$DEVPATH/data */
+    data_fd = open("data", O_WRONLY);
+    if (data_fd == -1)
+        goto out;
+    cnt = bb_copyfd_eof(firmware_fd, data_fd);
+
+    /* tell kernel result by `echo [0|-1] > /sys/$DEVPATH/loading` */
+    if (cnt > 0)
+        write(loading_fd, "0", 1);
+    else
+        write(loading_fd, "-1", 2);
+
+ out:
+    if (ENABLE_FEATURE_CLEAN_UP) {
+        close(firmware_fd);
+        close(loading_fd);
+        close(data_fd);
+    }
+}
+
+int mdev_main(int argc, char **argv);
+int mdev_main(int argc, char **argv)
 {
     char *action;
@@ -234 +295 @@
     RESERVE_CONFIG_BUFFER(temp,PATH_MAX);
 
-    bb_xchdir(DEV_PATH);
+    xchdir("/dev");
 
     /* Scan */
@@ -241 +302 @@
         struct stat st;
 
-        stat("/", &st);  // If this fails, we have bigger problems.
-        bbg.root_major=major(st.st_dev);
-        bbg.root_minor=minor(st.st_dev);
-        strcpy(temp,"/sys/block");
-        find_dev(temp);
-        strcpy(temp,"/sys/class");
-        find_dev(temp);
+        xstat("/", &st);
+        root_major = major(st.st_dev);
+        root_minor = minor(st.st_dev);
+
+        recursive_action("/sys/block",
+            ACTION_RECURSE | ACTION_FOLLOWLINKS,
+            fileAction, dirAction, temp, 0);
+
+        recursive_action("/sys/class",
+            ACTION_RECURSE | ACTION_FOLLOWLINKS,
+            fileAction, dirAction, temp, 0);
 
     /* Hotplug */
@@ -254 +319 @@
         action = getenv("ACTION");
         env_path = getenv("DEVPATH");
-        if (!action || !env_path)
+        if (!action || !env_path)
             bb_show_usage();
 
         sprintf(temp, "/sys%s", env_path);
-        if (!strcmp(action, "add")) make_device(temp,0);
-        else if (!strcmp(action, "remove")) make_device(temp,1);
+        if (!strcmp(action, "remove"))
+            make_device(temp, 1);
+        else if (!strcmp(action, "add")) {
+            make_device(temp, 0);
+
+            if (ENABLE_FEATURE_MDEV_LOAD_FIRMWARE)
+                load_firmware(getenv("FIRMWARE"), temp);
+        }
     }
 

branches/2.2.5/mindi-busybox/util-linux/mkfs_minix.c

@@ -34 +34 @@
  *      (Dr. Wettstein, greg%wind.uucp@plains.nodak.edu)
  *
- * 30.10.94 - added support for v2 filesystem
- *        (Andreas Schwab, schwab@issan.informatik.uni-dortmund.de)
+ * 30.10.94  -  added support for v2 filesystem
+ *          (Andreas Schwab, schwab@issan.informatik.uni-dortmund.de)
  *
  * 09.11.94  -  Added test to prevent overwrite of mounted fs adapted
@@ -63 +63 @@
  */
 
-#include <stdio.h>
-#include <time.h>
-#include <unistd.h>
-#include <string.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <termios.h>
-#include <sys/ioctl.h>
-#include <sys/param.h>
+#include "libbb.h"
 #include <mntent.h>
-#include "busybox.h"
-
-#define MINIX_ROOT_INO 1
-#define MINIX_LINK_MAX  250
-#define MINIX2_LINK_MAX 65530
-
-#define MINIX_I_MAP_SLOTS   8
-#define MINIX_Z_MAP_SLOTS   64
-#define MINIX_SUPER_MAGIC   0x137F      /* original minix fs */
-#define MINIX_SUPER_MAGIC2  0x138F      /* minix fs, 30 char names */
-#define MINIX2_SUPER_MAGIC  0x2468      /* minix V2 fs */
-#define MINIX2_SUPER_MAGIC2 0x2478      /* minix V2 fs, 30 char names */
-#define MINIX_VALID_FS      0x0001      /* Clean fs. */
-#define MINIX_ERROR_FS      0x0002      /* fs has errors. */
-
-#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
-#define MINIX2_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix2_inode)))
-
-#define MINIX_V1        0x0001      /* original minix fs */
-#define MINIX_V2        0x0002      /* minix V2 fs */
-
-#define INODE_VERSION(inode)    inode->i_sb->u.minix_sb.s_version
-
-/*
- * This is the original minix inode layout on disk.
- * Note the 8-bit gid and atime and ctime.
- */
-struct minix_inode {
-    uint16_t i_mode;
-    uint16_t i_uid;
-    uint32_t i_size;
-    uint32_t i_time;
-    uint8_t  i_gid;
-    uint8_t  i_nlinks;
-    uint16_t i_zone[9];
+
+#include "minix.h"
+
+#define DEBUG 0
+
+/* If debugging, store the very same times/uids/gids for image consistency */
+#if DEBUG
+# define CUR_TIME 0
+# define GETUID 0
+# define GETGID 0
+#else
+# define CUR_TIME time(NULL)
+# define GETUID getuid()
+# define GETGID getgid()
+#endif
+
+enum {
+    MAX_GOOD_BLOCKS         = 512,
+    TEST_BUFFER_BLOCKS      = 16,
 };
 
-/*
- * The new minix inode has all the time entries, as well as
- * long block numbers and a third indirect block (7+1+1+1
- * instead of 7+1+1). Also, some previously 8-bit values are
- * now 16-bit. The inode is now 64 bytes instead of 32.
- */
-struct minix2_inode {
-    uint16_t i_mode;
-    uint16_t i_nlinks;
-    uint16_t i_uid;
-    uint16_t i_gid;
-    uint32_t i_size;
-    uint32_t i_atime;
-    uint32_t i_mtime;
-    uint32_t i_ctime;
-    uint32_t i_zone[10];
+#if !ENABLE_FEATURE_MINIX2
+enum { version2 = 0 };
+#endif
+
+struct globals {
+    int dev_fd;
+
+#if ENABLE_FEATURE_MINIX2
+    smallint version2;
+#define version2 G.version2
+#endif
+    char *device_name;
+    uint32_t total_blocks;
+    int badblocks;
+    int namelen;
+    int dirsize;
+    int magic;
+    char *inode_buffer;
+    char *inode_map;
+    char *zone_map;
+    int used_good_blocks;
+    unsigned long req_nr_inodes;
+    unsigned currently_testing;
+
+
+    char root_block[BLOCK_SIZE];
+    char super_block_buffer[BLOCK_SIZE];
+    char boot_block_buffer[512];
+    unsigned short good_blocks_table[MAX_GOOD_BLOCKS];
+    /* check_blocks(): buffer[] was the biggest static in entire bbox */
+    char check_blocks_buffer[BLOCK_SIZE * TEST_BUFFER_BLOCKS];
 };
 
-/*
- * minix super-block data on disk
- */
-struct minix_super_block {
-    uint16_t s_ninodes;
-    uint16_t s_nzones;
-    uint16_t s_imap_blocks;
-    uint16_t s_zmap_blocks;
-    uint16_t s_firstdatazone;
-    uint16_t s_log_zone_size;
-    uint32_t s_max_size;
-    uint16_t s_magic;
-    uint16_t s_state;
-    uint32_t s_zones;
-};
-
-struct minix_dir_entry {
-    uint16_t inode;
-    char name[0];
-};
-
-#define NAME_MAX         255   /* # chars in a file name */
-
-#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
-
-#define MINIX_VALID_FS               0x0001          /* Clean fs. */
-#define MINIX_ERROR_FS               0x0002          /* fs has errors. */
-
-#define MINIX_SUPER_MAGIC    0x137F          /* original minix fs */
-#define MINIX_SUPER_MAGIC2   0x138F          /* minix fs, 30 char names */
+#define G (*ptr_to_globals)
+
+static ALWAYS_INLINE unsigned div_roundup(unsigned size, unsigned n)
+{
+    return (size + n-1) / n;
+}
+
+#define INODE_BUF1              (((struct minix1_inode*)G.inode_buffer) - 1)
+#define INODE_BUF2              (((struct minix2_inode*)G.inode_buffer) - 1)
+
+#define SB                      (*(struct minix_super_block*)G.super_block_buffer)
+
+#define SB_INODES               (SB.s_ninodes)
+#define SB_IMAPS                (SB.s_imap_blocks)
+#define SB_ZMAPS                (SB.s_zmap_blocks)
+#define SB_FIRSTZONE            (SB.s_firstdatazone)
+#define SB_ZONE_SIZE            (SB.s_log_zone_size)
+#define SB_MAXSIZE              (SB.s_max_size)
+#define SB_MAGIC                (SB.s_magic)
+
+#if !ENABLE_FEATURE_MINIX2
+# define SB_ZONES               (SB.s_nzones)
+# define INODE_BLOCKS           div_roundup(SB_INODES, MINIX1_INODES_PER_BLOCK)
+#else
+# define SB_ZONES               (version2 ? SB.s_zones : SB.s_nzones)
+# define INODE_BLOCKS           div_roundup(SB_INODES, \
+                                version2 ? MINIX2_INODES_PER_BLOCK : MINIX1_INODES_PER_BLOCK)
+#endif
+
+#define INODE_BUFFER_SIZE       (INODE_BLOCKS * BLOCK_SIZE)
+#define NORM_FIRSTZONE          (2 + SB_IMAPS + SB_ZMAPS + INODE_BLOCKS)
+
+/* Before you ask "where they come from?": */
+/* setbit/clrbit are supplied by sys/param.h */
+
+static int minix_bit(const char* a, unsigned i)
+{
+      return a[i >> 3] & (1<<(i & 7));
+}
+
+static void minix_setbit(char *a, unsigned i)
+{
+    setbit(a, i);
+}
+static void minix_clrbit(char *a, unsigned i)
+{
+    clrbit(a, i);
+}
+
+/* Note: do not assume 0/1, it is 0/nonzero */
+#define zone_in_use(x)  minix_bit(G.zone_map,(x)-SB_FIRSTZONE+1)
+/*#define inode_in_use(x) minix_bit(G.inode_map,(x))*/
+
+#define mark_inode(x)   minix_setbit(G.inode_map,(x))
+#define unmark_inode(x) minix_clrbit(G.inode_map,(x))
+#define mark_zone(x)    minix_setbit(G.zone_map,(x)-SB_FIRSTZONE+1)
+#define unmark_zone(x)  minix_clrbit(G.zone_map,(x)-SB_FIRSTZONE+1)
 
 #ifndef BLKGETSIZE
-#define BLKGETSIZE _IO(0x12,96)    /* return device size */
-#endif
-
-
-#ifndef __linux__
-#define volatile
-#endif
-
-#define MINIX_ROOT_INO 1
-#define MINIX_BAD_INO 2
-
-#define TEST_BUFFER_BLOCKS 16
-#define MAX_GOOD_BLOCKS 512
-
-#define UPPER(size,n) (((size)+((n)-1))/(n))
-#define INODE_SIZE (sizeof(struct minix_inode))
-#ifdef CONFIG_FEATURE_MINIX2
-#define INODE_SIZE2 (sizeof(struct minix2_inode))
-#define INODE_BLOCKS UPPER(INODES, (version2 ? MINIX2_INODES_PER_BLOCK \
-                    : MINIX_INODES_PER_BLOCK))
-#else
-#define INODE_BLOCKS UPPER(INODES, (MINIX_INODES_PER_BLOCK))
-#endif
-#define INODE_BUFFER_SIZE (INODE_BLOCKS * BLOCK_SIZE)
-
-#define BITS_PER_BLOCK (BLOCK_SIZE<<3)
-
-static char *device_name;
-static int DEV = -1;
-static uint32_t BLOCKS;
-static int check;
-static int badblocks;
-static int namelen = 30;        /* default (changed to 30, per Linus's
-
-                                   suggestion, Sun Nov 21 08:05:07 1993) */
-static int dirsize = 32;
-static int magic = MINIX_SUPER_MAGIC2;
-static int version2;
-
-static char root_block[BLOCK_SIZE];
-
-static char *inode_buffer;
-
-#define Inode (((struct minix_inode *) inode_buffer)-1)
-#ifdef CONFIG_FEATURE_MINIX2
-#define Inode2 (((struct minix2_inode *) inode_buffer)-1)
-#endif
-static char super_block_buffer[BLOCK_SIZE];
-static char boot_block_buffer[512];
-
-#define Super (*(struct minix_super_block *)super_block_buffer)
-#define INODES (Super.s_ninodes)
-#ifdef CONFIG_FEATURE_MINIX2
-#define ZONES (version2 ? Super.s_zones : Super.s_nzones)
-#else
-#define ZONES (Super.s_nzones)
-#endif
-#define IMAPS (Super.s_imap_blocks)
-#define ZMAPS (Super.s_zmap_blocks)
-#define FIRSTZONE (Super.s_firstdatazone)
-#define ZONESIZE (Super.s_log_zone_size)
-#define MAXSIZE (Super.s_max_size)
-#define MAGIC (Super.s_magic)
-#define NORM_FIRSTZONE (2+IMAPS+ZMAPS+INODE_BLOCKS)
-
-static char *inode_map;
-static char *zone_map;
-
-static unsigned short good_blocks_table[MAX_GOOD_BLOCKS];
-static int used_good_blocks;
-static unsigned long req_nr_inodes;
-
-static inline int bit(char * a,unsigned int i)
-{
-      return (a[i >> 3] & (1<<(i & 7))) != 0;
-}
-#define inode_in_use(x) (bit(inode_map,(x)))
-#define zone_in_use(x) (bit(zone_map,(x)-FIRSTZONE+1))
-
-#define mark_inode(x) (setbit(inode_map,(x)))
-#define unmark_inode(x) (clrbit(inode_map,(x)))
-
-#define mark_zone(x) (setbit(zone_map,(x)-FIRSTZONE+1))
-#define unmark_zone(x) (clrbit(zone_map,(x)-FIRSTZONE+1))
-
-/*
- * Check to make certain that our new filesystem won't be created on
- * an already mounted partition.  Code adapted from mke2fs, Copyright
- * (C) 1994 Theodore Ts'o.  Also licensed under GPL.
- */
-static inline void check_mount(void)
-{
-    FILE *f;
-    struct mntent *mnt;
-
-    if ((f = setmntent(MOUNTED, "r")) == NULL)
-        return;
-    while ((mnt = getmntent(f)) != NULL)
-        if (strcmp(device_name, mnt->mnt_fsname) == 0)
-            break;
-    endmntent(f);
-    if (!mnt)
-        return;
-
-    bb_error_msg_and_die("%s is mounted; will not make a filesystem here!", device_name);
-}
+# define BLKGETSIZE     _IO(0x12,96)    /* return device size */
+#endif
+
 
 static long valid_offset(int fd, int offset)
@@ -274 +186 @@
     char ch;
 
-    if (lseek(fd, offset, 0) < 0)
+    if (lseek(fd, offset, SEEK_SET) < 0)
         return 0;
     if (read(fd, &ch, 1) < 1)
@@ -281 +193 @@
 }
 
-static inline int count_blocks(int fd)
+static int count_blocks(int fd)
 {
     int high, low;
@@ -288 +200 @@
     for (high = 1; valid_offset(fd, high); high *= 2)
         low = high;
+
     while (low < high - 1) {
         const int mid = (low + high) / 2;
@@ -300 +213 @@
 }
 
-static inline int get_size(const char *file)
+static int get_size(const char *file)
 {
     int fd;
     long size;
 
-    fd = bb_xopen3(file, O_RDWR, 0);
+    fd = xopen(file, O_RDWR);
     if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
         close(fd);
@@ -316 +229 @@
 }
 
-static inline void write_tables(void)
+static void write_tables(void)
 {
     /* Mark the super block valid. */
-    Super.s_state |= MINIX_VALID_FS;
-    Super.s_state &= ~MINIX_ERROR_FS;
-
-    if (lseek(DEV, 0, SEEK_SET))
-        bb_error_msg_and_die("seek to boot block failed in write_tables");
-    if (512 != write(DEV, boot_block_buffer, 512))
-        bb_error_msg_and_die("unable to clear boot sector");
-    if (BLOCK_SIZE != lseek(DEV, BLOCK_SIZE, SEEK_SET))
-        bb_error_msg_and_die("seek failed in write_tables");
-    if (BLOCK_SIZE != write(DEV, super_block_buffer, BLOCK_SIZE))
-        bb_error_msg_and_die("unable to write super-block");
-    if (IMAPS * BLOCK_SIZE != write(DEV, inode_map, IMAPS * BLOCK_SIZE))
-        bb_error_msg_and_die("unable to write inode map");
-    if (ZMAPS * BLOCK_SIZE != write(DEV, zone_map, ZMAPS * BLOCK_SIZE))
-        bb_error_msg_and_die("unable to write zone map");
-    if (INODE_BUFFER_SIZE != write(DEV, inode_buffer, INODE_BUFFER_SIZE))
-        bb_error_msg_and_die("unable to write inodes");
-
+    SB.s_state |= MINIX_VALID_FS;
+    SB.s_state &= ~MINIX_ERROR_FS;
+
+    msg_eol = "seek to 0 failed";
+    xlseek(G.dev_fd, 0, SEEK_SET);
+
+    msg_eol = "cannot clear boot sector";
+    xwrite(G.dev_fd, G.boot_block_buffer, 512);
+
+    msg_eol = "seek to BLOCK_SIZE failed";
+    xlseek(G.dev_fd, BLOCK_SIZE, SEEK_SET);
+
+    msg_eol = "cannot write superblock";
+    xwrite(G.dev_fd, G.super_block_buffer, BLOCK_SIZE);
+
+    msg_eol = "cannot write inode map";
+    xwrite(G.dev_fd, G.inode_map, SB_IMAPS * BLOCK_SIZE);
+
+    msg_eol = "cannot write zone map";
+    xwrite(G.dev_fd, G.zone_map, SB_ZMAPS * BLOCK_SIZE);
+
+    msg_eol = "cannot write inodes";
+    xwrite(G.dev_fd, G.inode_buffer, INODE_BUFFER_SIZE);
+
+    msg_eol = "\n";
 }
 
 static void write_block(int blk, char *buffer)
 {
-    if (blk * BLOCK_SIZE != lseek(DEV, blk * BLOCK_SIZE, SEEK_SET))
-        bb_error_msg_and_die("seek failed in write_block");
-    if (BLOCK_SIZE != write(DEV, buffer, BLOCK_SIZE))
-        bb_error_msg_and_die("write failed in write_block");
+    xlseek(G.dev_fd, blk * BLOCK_SIZE, SEEK_SET);
+    xwrite(G.dev_fd, buffer, BLOCK_SIZE);
 }
 
@@ -351 +269 @@
     int blk;
 
-    if (used_good_blocks + 1 >= MAX_GOOD_BLOCKS)
+    if (G.used_good_blocks + 1 >= MAX_GOOD_BLOCKS)
         bb_error_msg_and_die("too many bad blocks");
-    if (used_good_blocks)
-        blk = good_blocks_table[used_good_blocks - 1] + 1;
+    if (G.used_good_blocks)
+        blk = G.good_blocks_table[G.used_good_blocks - 1] + 1;
     else
-        blk = FIRSTZONE;
-    while (blk < ZONES && zone_in_use(blk))
+        blk = SB_FIRSTZONE;
+    while (blk < SB_ZONES && zone_in_use(blk))
         blk++;
-    if (blk >= ZONES)
+    if (blk >= SB_ZONES)
         bb_error_msg_and_die("not enough good blocks");
-    good_blocks_table[used_good_blocks] = blk;
-    used_good_blocks++;
+    G.good_blocks_table[G.used_good_blocks] = blk;
+    G.used_good_blocks++;
     return blk;
 }
 
-static inline void mark_good_blocks(void)
+static void mark_good_blocks(void)
 {
     int blk;
 
-    for (blk = 0; blk < used_good_blocks; blk++)
-        mark_zone(good_blocks_table[blk]);
+    for (blk = 0; blk < G.used_good_blocks; blk++)
+        mark_zone(G.good_blocks_table[blk]);
 }
 
@@ -377 +295 @@
 {
     if (!zone)
-        zone = FIRSTZONE - 1;
-    while (++zone < ZONES)
+        zone = SB_FIRSTZONE - 1;
+    while (++zone < SB_ZONES)
         if (zone_in_use(zone))
             return zone;
@@ -384 +302 @@
 }
 
-static inline void make_bad_inode(void)
-{
-    struct minix_inode *inode = &Inode[MINIX_BAD_INO];
+static void make_bad_inode(void)
+{
+    struct minix1_inode *inode = &INODE_BUF1[MINIX_BAD_INO];
     int i, j, zone;
     int ind = 0, dind = 0;
@@ -394 +312 @@
 #define NEXT_BAD (zone = next(zone))
 
-    if (!badblocks)
+    if (!G.badblocks)
         return;
     mark_inode(MINIX_BAD_INO);
     inode->i_nlinks = 1;
-    inode->i_time = time(NULL);
+    /* BTW, setting this makes all images different */
+    /* it's harder to check for bugs then - diff isn't helpful :(... */
+    inode->i_time = CUR_TIME;
     inode->i_mode = S_IFREG + 0000;
-    inode->i_size = badblocks * BLOCK_SIZE;
+    inode->i_size = G.badblocks * BLOCK_SIZE;
     zone = next(0);
     for (i = 0; i < 7; i++) {
@@ -427 +347 @@
     }
     bb_error_msg_and_die("too many bad blocks");
-  end_bad:
+ end_bad:
     if (ind)
         write_block(ind, (char *) ind_block);
@@ -434 +354 @@
 }
 
-#ifdef CONFIG_FEATURE_MINIX2
-static inline void make_bad_inode2(void)
-{
-    struct minix2_inode *inode = &Inode2[MINIX_BAD_INO];
+#if ENABLE_FEATURE_MINIX2
+static void make_bad_inode2(void)
+{
+    struct minix2_inode *inode = &INODE_BUF2[MINIX_BAD_INO];
     int i, j, zone;
     int ind = 0, dind = 0;
@@ -443 +363 @@
     unsigned long dind_block[BLOCK_SIZE >> 2];
 
-    if (!badblocks)
+    if (!G.badblocks)
         return;
     mark_inode(MINIX_BAD_INO);
     inode->i_nlinks = 1;
-    inode->i_atime = inode->i_mtime = inode->i_ctime = time(NULL);
+    inode->i_atime = inode->i_mtime = inode->i_ctime = CUR_TIME;
     inode->i_mode = S_IFREG + 0000;
-    inode->i_size = badblocks * BLOCK_SIZE;
+    inode->i_size = G.badblocks * BLOCK_SIZE;
     zone = next(0);
     for (i = 0; i < 7; i++) {
@@ -477 +397 @@
     /* Could make triple indirect block here */
     bb_error_msg_and_die("too many bad blocks");
-  end_bad:
+ end_bad:
     if (ind)
         write_block(ind, (char *) ind_block);
@@ -483 +403 @@
         write_block(dind, (char *) dind_block);
 }
-#endif
-
-static inline void make_root_inode(void)
-{
-    struct minix_inode *inode = &Inode[MINIX_ROOT_INO];
+#else
+void make_bad_inode2(void);
+#endif
+
+static void make_root_inode(void)
+{
+    struct minix1_inode *inode = &INODE_BUF1[MINIX_ROOT_INO];
 
     mark_inode(MINIX_ROOT_INO);
     inode->i_zone[0] = get_free_block();
     inode->i_nlinks = 2;
-    inode->i_time = time(NULL);
-    if (badblocks)
-        inode->i_size = 3 * dirsize;
+    inode->i_time = CUR_TIME;
+    if (G.badblocks)
+        inode->i_size = 3 * G.dirsize;
     else {
-        root_block[2 * dirsize] = '\0';
-        root_block[2 * dirsize + 1] = '\0';
-        inode->i_size = 2 * dirsize;
+        G.root_block[2 * G.dirsize] = '\0';
+        G.root_block[2 * G.dirsize + 1] = '\0';
+        inode->i_size = 2 * G.dirsize;
     }
     inode->i_mode = S_IFDIR + 0755;
-    inode->i_uid = getuid();
+    inode->i_uid = GETUID;
     if (inode->i_uid)
-        inode->i_gid = getgid();
-    write_block(inode->i_zone[0], root_block);
-}
-
-#ifdef CONFIG_FEATURE_MINIX2
-static inline void make_root_inode2(void)
-{
-    struct minix2_inode *inode = &Inode2[MINIX_ROOT_INO];
+        inode->i_gid = GETGID;
+    write_block(inode->i_zone[0], G.root_block);
+}
+
+#if ENABLE_FEATURE_MINIX2
+static void make_root_inode2(void)
+{
+    struct minix2_inode *inode = &INODE_BUF2[MINIX_ROOT_INO];
 
     mark_inode(MINIX_ROOT_INO);
     inode->i_zone[0] = get_free_block();
     inode->i_nlinks = 2;
-    inode->i_atime = inode->i_mtime = inode->i_ctime = time(NULL);
-    if (badblocks)
-        inode->i_size = 3 * dirsize;
+    inode->i_atime = inode->i_mtime = inode->i_ctime = CUR_TIME;
+    if (G.badblocks)
+        inode->i_size = 3 * G.dirsize;
     else {
-        root_block[2 * dirsize] = '\0';
-        root_block[2 * dirsize + 1] = '\0';
-        inode->i_size = 2 * dirsize;
+        G.root_block[2 * G.dirsize] = '\0';
+        G.root_block[2 * G.dirsize + 1] = '\0';
+        inode->i_size = 2 * G.dirsize;
     }
     inode->i_mode = S_IFDIR + 0755;
-    inode->i_uid = getuid();
+    inode->i_uid = GETUID;
     if (inode->i_uid)
-        inode->i_gid = getgid();
-    write_block(inode->i_zone[0], root_block);
-}
-#endif
-
-static inline void setup_tables(void)
-{
-    int i;
+        inode->i_gid = GETGID;
+    write_block(inode->i_zone[0], G.root_block);
+}
+#else
+void make_root_inode2(void);
+#endif
+
+/*
+ * Perform a test of a block; return the number of
+ * blocks readable.
+ */
+static size_t do_check(char *buffer, size_t try, unsigned current_block)
+{
+    ssize_t got;
+
+    /* Seek to the correct loc. */
+    msg_eol = "seek failed during testing of blocks";
+    xlseek(G.dev_fd, current_block * BLOCK_SIZE, SEEK_SET);
+    msg_eol = "\n";
+
+    /* Try the read */
+    got = read(G.dev_fd, buffer, try * BLOCK_SIZE);
+    if (got < 0)
+        got = 0;
+    try = ((size_t)got) / BLOCK_SIZE;
+
+    if (got & (BLOCK_SIZE - 1))
+        fprintf(stderr, "Short read at block %u\n", (unsigned)(current_block + try));
+    return try;
+}
+
+static void alarm_intr(int alnum)
+{
+    if (G.currently_testing >= SB_ZONES)
+        return;
+    signal(SIGALRM, alarm_intr);
+    alarm(5);
+    if (!G.currently_testing)
+        return;
+    printf("%d ...", G.currently_testing);
+    fflush(stdout);
+}
+
+static void check_blocks(void)
+{
+    size_t try, got;
+
+    G.currently_testing = 0;
+    signal(SIGALRM, alarm_intr);
+    alarm(5);
+    while (G.currently_testing < SB_ZONES) {
+        msg_eol = "seek failed in check_blocks";
+        xlseek(G.dev_fd, G.currently_testing * BLOCK_SIZE, SEEK_SET);
+        msg_eol = "\n";
+        try = TEST_BUFFER_BLOCKS;
+        if (G.currently_testing + try > SB_ZONES)
+            try = SB_ZONES - G.currently_testing;
+        got = do_check(G.check_blocks_buffer, try, G.currently_testing);
+        G.currently_testing += got;
+        if (got == try)
+            continue;
+        if (G.currently_testing < SB_FIRSTZONE)
+            bb_error_msg_and_die("bad blocks before data-area: cannot make fs");
+        mark_zone(G.currently_testing);
+        G.badblocks++;
+        G.currently_testing++;
+    }
+    alarm(0);
+    printf("%d bad block(s)\n", G.badblocks);
+}
+
+static void get_list_blocks(char *filename)
+{
+    FILE *listfile;
+    unsigned long blockno;
+
+    listfile = xfopen(filename, "r");
+    while (!feof(listfile)) {
+        fscanf(listfile, "%ld\n", &blockno);
+        mark_zone(blockno);
+        G.badblocks++;
+    }
+    printf("%d bad block(s)\n", G.badblocks);
+}
+
+static void setup_tables(void)
+{
     unsigned long inodes;
-
-    memset(super_block_buffer, 0, BLOCK_SIZE);
-    memset(boot_block_buffer, 0, 512);
-    MAGIC = magic;
-    ZONESIZE = 0;
-    MAXSIZE = version2 ? 0x7fffffff : (7 + 512 + 512 * 512) * 1024;
-#ifdef CONFIG_FEATURE_MINIX2
-    if (version2) {
-        Super.s_zones =  BLOCKS;
-    } else
-#endif
-        Super.s_nzones = BLOCKS;
-
-/* some magic nrs: 1 inode / 3 blocks */
-    if (req_nr_inodes == 0)
-        inodes = BLOCKS / 3;
+    unsigned norm_firstzone;
+    unsigned sb_zmaps;
+    unsigned i;
+
+    /* memset(G.super_block_buffer, 0, BLOCK_SIZE); */
+    /* memset(G.boot_block_buffer, 0, 512); */
+    SB_MAGIC = G.magic;
+    SB_ZONE_SIZE = 0;
+    SB_MAXSIZE = version2 ? 0x7fffffff : (7 + 512 + 512 * 512) * 1024;
+    if (version2)
+        SB.s_zones = G.total_blocks;
     else
-        inodes = req_nr_inodes;
+        SB.s_nzones = G.total_blocks;
+
+    /* some magic nrs: 1 inode / 3 blocks */
+    if (G.req_nr_inodes == 0)
+        inodes = G.total_blocks / 3;
+    else
+        inodes = G.req_nr_inodes;
     /* Round up inode count to fill block size */
-#ifdef CONFIG_FEATURE_MINIX2
     if (version2)
-        inodes = ((inodes + MINIX2_INODES_PER_BLOCK - 1) &
-                  ~(MINIX2_INODES_PER_BLOCK - 1));
+        inodes = (inodes + MINIX2_INODES_PER_BLOCK - 1) &
+                         ~(MINIX2_INODES_PER_BLOCK - 1);
     else
-#endif
-        inodes = ((inodes + MINIX_INODES_PER_BLOCK - 1) &
-                  ~(MINIX_INODES_PER_BLOCK - 1));
+        inodes = (inodes + MINIX1_INODES_PER_BLOCK - 1) &
+                         ~(MINIX1_INODES_PER_BLOCK - 1);
     if (inodes > 65535)
         inodes = 65535;
-    INODES = inodes;
-    IMAPS = UPPER(INODES + 1, BITS_PER_BLOCK);
-    ZMAPS = 0;
-    i = 0;
-    while (ZMAPS !=
-           UPPER(BLOCKS - (2 + IMAPS + ZMAPS + INODE_BLOCKS) + 1,
-                 BITS_PER_BLOCK) && i < 1000) {
-        ZMAPS =
-            UPPER(BLOCKS - (2 + IMAPS + ZMAPS + INODE_BLOCKS) + 1,
-                  BITS_PER_BLOCK);
-        i++;
-    }
+    SB_INODES = inodes;
+    SB_IMAPS = div_roundup(SB_INODES + 1, BITS_PER_BLOCK);
+
     /* Real bad hack but overwise mkfs.minix can be thrown
      * in infinite loop...
      * try:
      * dd if=/dev/zero of=test.fs count=10 bs=1024
-     * /sbin/mkfs.minix -i 200 test.fs
-     * */
-    if (i >= 999) {
-        bb_error_msg_and_die("unable to allocate buffers for maps");
-    }
-    FIRSTZONE = NORM_FIRSTZONE;
-    inode_map = xmalloc(IMAPS * BLOCK_SIZE);
-    zone_map = xmalloc(ZMAPS * BLOCK_SIZE);
-    memset(inode_map, 0xff, IMAPS * BLOCK_SIZE);
-    memset(zone_map, 0xff, ZMAPS * BLOCK_SIZE);
-    for (i = FIRSTZONE; i < ZONES; i++)
+     * mkfs.minix -i 200 test.fs
+     */
+    /* This code is not insane: NORM_FIRSTZONE is not a constant,
+     * it is calculated from SB_INODES, SB_IMAPS and SB_ZMAPS */
+    i = 999;
+    SB_ZMAPS = 0;
+    do {
+        norm_firstzone = NORM_FIRSTZONE;
+        sb_zmaps = div_roundup(G.total_blocks - norm_firstzone + 1, BITS_PER_BLOCK);
+        if (SB_ZMAPS == sb_zmaps) goto got_it;
+        SB_ZMAPS = sb_zmaps;
+        /* new SB_ZMAPS, need to recalc NORM_FIRSTZONE */
+    } while (--i);
+    bb_error_msg_and_die("incompatible size/inode count, try different -i N");
+ got_it:
+
+    SB_FIRSTZONE = norm_firstzone;
+    G.inode_map = xmalloc(SB_IMAPS * BLOCK_SIZE);
+    G.zone_map = xmalloc(SB_ZMAPS * BLOCK_SIZE);
+    memset(G.inode_map, 0xff, SB_IMAPS * BLOCK_SIZE);
+    memset(G.zone_map, 0xff, SB_ZMAPS * BLOCK_SIZE);
+    for (i = SB_FIRSTZONE; i < SB_ZONES; i++)
         unmark_zone(i);
-    for (i = MINIX_ROOT_INO; i <= INODES; i++)
+    for (i = MINIX_ROOT_INO; i <= SB_INODES; i++)
         unmark_inode(i);
-    inode_buffer = xmalloc(INODE_BUFFER_SIZE);
-    memset(inode_buffer, 0, INODE_BUFFER_SIZE);
-    printf("%ld inodes\n", (long)INODES);
-    printf("%ld blocks\n", (long)ZONES);
-    printf("Firstdatazone=%ld (%ld)\n", (long)FIRSTZONE, (long)NORM_FIRSTZONE);
-    printf("Zonesize=%d\n", BLOCK_SIZE << ZONESIZE);
-    printf("Maxsize=%ld\n\n", (long)MAXSIZE);
-}
-
-/*
- * Perform a test of a block; return the number of
- * blocks readable/writable.
- */
-static inline long do_check(char *buffer, int try, unsigned int current_block)
-{
-    long got;
-
-    /* Seek to the correct loc. */
-    if (lseek(DEV, current_block * BLOCK_SIZE, SEEK_SET) !=
-        current_block * BLOCK_SIZE) {
-        bb_error_msg_and_die("seek failed during testing of blocks");
-    }
-
-
-    /* Try the read */
-    got = read(DEV, buffer, try * BLOCK_SIZE);
-    if (got < 0)
-        got = 0;
-    if (got & (BLOCK_SIZE - 1)) {
-        printf("Weird values in do_check: probably bugs\n");
-    }
-    got /= BLOCK_SIZE;
-    return got;
-}
-
-static unsigned int currently_testing;
-
-static void alarm_intr(int alnum)
-{
-    if (currently_testing >= ZONES)
-        return;
-    signal(SIGALRM, alarm_intr);
-    alarm(5);
-    if (!currently_testing)
-        return;
-    printf("%d ...", currently_testing);
-    fflush(stdout);
-}
-
-static void check_blocks(void)
-{
-    int try, got;
-    static char buffer[BLOCK_SIZE * TEST_BUFFER_BLOCKS];
-
-    currently_testing = 0;
-    signal(SIGALRM, alarm_intr);
-    alarm(5);
-    while (currently_testing < ZONES) {
-        if (lseek(DEV, currently_testing * BLOCK_SIZE, SEEK_SET) !=
-            currently_testing * BLOCK_SIZE)
-            bb_error_msg_and_die("seek failed in check_blocks");
-        try = TEST_BUFFER_BLOCKS;
-        if (currently_testing + try > ZONES)
-            try = ZONES - currently_testing;
-        got = do_check(buffer, try, currently_testing);
-        currently_testing += got;
-        if (got == try)
-            continue;
-        if (currently_testing < FIRSTZONE)
-            bb_error_msg_and_die("bad blocks before data-area: cannot make fs");
-        mark_zone(currently_testing);
-        badblocks++;
-        currently_testing++;
-    }
-    if (badblocks > 1)
-        printf("%d bad blocks\n", badblocks);
-    else if (badblocks == 1)
-        printf("one bad block\n");
-}
-
-static void get_list_blocks(char *filename)
-{
-    FILE *listfile;
-    unsigned long blockno;
-
-    listfile = bb_xfopen(filename, "r");
-    while (!feof(listfile)) {
-        fscanf(listfile, "%ld\n", &blockno);
-        mark_zone(blockno);
-        badblocks++;
-    }
-    if (badblocks > 1)
-        printf("%d bad blocks\n", badblocks);
-    else if (badblocks == 1)
-        printf("one bad block\n");
-}
-
+    G.inode_buffer = xzalloc(INODE_BUFFER_SIZE);
+    printf("%ld inodes\n", (long)SB_INODES);
+    printf("%ld blocks\n", (long)SB_ZONES);
+    printf("Firstdatazone=%ld (%ld)\n", (long)SB_FIRSTZONE, (long)norm_firstzone);
+    printf("Zonesize=%d\n", BLOCK_SIZE << SB_ZONE_SIZE);
+    printf("Maxsize=%ld\n", (long)SB_MAXSIZE);
+}
+
+int mkfs_minix_main(int argc, char **argv);
 int mkfs_minix_main(int argc, char **argv)
 {
-    int i=1;
+    struct mntent *mp;
+    unsigned opt;
     char *tmp;
     struct stat statbuf;
+    char *str_i, *str_n;
     char *listfile = NULL;
-    int stopIt=FALSE;
-
-    if (INODE_SIZE * MINIX_INODES_PER_BLOCK != BLOCK_SIZE)
+
+    PTR_TO_GLOBALS = xzalloc(sizeof(G));
+/* default (changed to 30, per Linus's suggestion, Sun Nov 21 08:05:07 1993) */
+    G.namelen = 30;
+    G.dirsize = 32;
+    G.magic = MINIX1_SUPER_MAGIC2;
+
+    if (INODE_SIZE1 * MINIX1_INODES_PER_BLOCK != BLOCK_SIZE)
         bb_error_msg_and_die("bad inode size");
-#ifdef CONFIG_FEATURE_MINIX2
+#if ENABLE_FEATURE_MINIX2
     if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE)
         bb_error_msg_and_die("bad inode size");
 #endif
 
-    /* Parse options */
-    argv++;
-    while (--argc >= 0 && *argv && **argv) {
-        if (**argv == '-') {
-            stopIt=FALSE;
-            while (i > 0 && *++(*argv) && stopIt==FALSE) {
-                switch (**argv) {
-                    case 'c':
-                        check = 1;
-                        break;
-                    case 'i':
-                        {
-                            char *cp=NULL;
-                            if (*(*argv+1) != 0) {
-                                cp = ++(*argv);
-                            } else {
-                                if (--argc == 0) {
-                                    goto goodbye;
-                                }
-                                cp = *(++argv);
-                            }
-                            req_nr_inodes = strtoul(cp, &tmp, 0);
-                            if (*tmp)
-                                bb_show_usage();
-                            stopIt=TRUE;
-                            break;
-                        }
-                    case 'l':
-                        if (--argc == 0) {
-                            goto goodbye;
-                        }
-                        listfile = *(++argv);
-                        break;
-                    case 'n':
-                        {
-                            char *cp=NULL;
-
-                            if (*(*argv+1) != 0) {
-                                cp = ++(*argv);
-                            } else {
-                                if (--argc == 0) {
-                                    goto goodbye;
-                                }
-                                cp = *(++argv);
-                            }
-                            i = strtoul(cp, &tmp, 0);
-                            if (*tmp)
-                                bb_show_usage();
-                            if (i == 14)
-                                magic = MINIX_SUPER_MAGIC;
-                            else if (i == 30)
-                                magic = MINIX_SUPER_MAGIC2;
-                            else
-                                bb_show_usage();
-                            namelen = i;
-                            dirsize = i + 2;
-                            stopIt=TRUE;
-                            break;
-                        }
-                    case 'v':
-#ifdef CONFIG_FEATURE_MINIX2
-                        version2 = 1;
+    opt = getopt32(argv, "ci:l:n:v", &str_i, &listfile, &str_n);
+    argv += optind;
+    //if (opt & 1) -c
+    if (opt & 2) G.req_nr_inodes = xatoul(str_i); // -i
+    //if (opt & 4) -l
+    if (opt & 8) { // -n
+        G.namelen = xatoi_u(str_n);
+        if (G.namelen == 14) G.magic = MINIX1_SUPER_MAGIC;
+        else if (G.namelen == 30) G.magic = MINIX1_SUPER_MAGIC2;
+        else bb_show_usage();
+        G.dirsize = G.namelen + 2;
+    }
+    if (opt & 0x10) { // -v
+#if ENABLE_FEATURE_MINIX2
+        version2 = 1;
 #else
-                        bb_error_msg("%s: not compiled with minix v2 support",
-                                device_name);
-                        exit(-1);
-#endif
-                        break;
-                    case '-':
-                    case 'h':
-                    default:
-goodbye:
-                        bb_show_usage();
-                }
-            }
-        } else {
-            if (device_name == NULL)
-                device_name = *argv;
-            else if (BLOCKS == 0)
-                BLOCKS = strtol(*argv, &tmp, 0);
-            else {
-                goto goodbye;
-            }
-        }
-        argv++;
-    }
-
-    if (device_name && !BLOCKS)
-        BLOCKS = get_size(device_name) / 1024;
-    if (!device_name || BLOCKS < 10) {
+        bb_error_msg_and_die("not compiled with minix v2 support");
+#endif
+    }
+
+    G.device_name = *argv++;
+    if (!G.device_name)
         bb_show_usage();
-    }
-#ifdef CONFIG_FEATURE_MINIX2
+    if (*argv)
+        G.total_blocks = xatou32(*argv);
+    else
+        G.total_blocks = get_size(G.device_name) / 1024;
+
+    if (G.total_blocks < 10)
+        bb_error_msg_and_die("must have at least 10 blocks");
+
     if (version2) {
-        if (namelen == 14)
-            magic = MINIX2_SUPER_MAGIC;
-        else
-            magic = MINIX2_SUPER_MAGIC2;
-    } else
-#endif
-    if (BLOCKS > 65535)
-        BLOCKS = 65535;
-    check_mount();              /* is it already mounted? */
-    tmp = root_block;
+        G.magic = MINIX2_SUPER_MAGIC2;
+        if (G.namelen == 14)
+            G.magic = MINIX2_SUPER_MAGIC;
+    } else if (G.total_blocks > 65535)
+        G.total_blocks = 65535;
+
+    /* Check if it is mounted */
+    mp = find_mount_point(G.device_name, NULL);
+    if (mp && strcmp(G.device_name, mp->mnt_fsname) == 0)
+        bb_error_msg_and_die("%s is mounted on %s; "
+                "refusing to make a filesystem",
+                G.device_name, mp->mnt_dir);
+
+    G.dev_fd = xopen(G.device_name, O_RDWR);
+    if (fstat(G.dev_fd, &statbuf) < 0)
+        bb_error_msg_and_die("cannot stat %s", G.device_name);
+    if (!S_ISBLK(statbuf.st_mode))
+        opt &= ~1; // clear -c (check)
+
+/* I don't know why someone has special code to prevent mkfs.minix
+ * on IDE devices. Why IDE but not SCSI, etc?... */
+#if 0
+    else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
+        /* what is this? */
+        bb_error_msg_and_die("will not try "
+            "to make filesystem on '%s'", G.device_name);
+#endif
+
+    tmp = G.root_block;
     *(short *) tmp = 1;
     strcpy(tmp + 2, ".");
-    tmp += dirsize;
+    tmp += G.dirsize;
     *(short *) tmp = 1;
     strcpy(tmp + 2, "..");
-    tmp += dirsize;
+    tmp += G.dirsize;
     *(short *) tmp = 2;
     strcpy(tmp + 2, ".badblocks");
-    DEV = bb_xopen3(device_name, O_RDWR, 0);
-    if (fstat(DEV, &statbuf) < 0)
-        bb_error_msg_and_die("unable to stat %s", device_name);
-    if (!S_ISBLK(statbuf.st_mode))
-        check = 0;
-    else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
-        bb_error_msg_and_die("will not try to make filesystem on '%s'", device_name);
+
     setup_tables();
-    if (check)
+
+    if (opt & 1) // -c ?
         check_blocks();
     else if (listfile)
         get_list_blocks(listfile);
-#ifdef CONFIG_FEATURE_MINIX2
+
     if (version2) {
         make_root_inode2();
         make_bad_inode2();
-    } else
-#endif
-    {
+    } else {
         make_root_inode();
         make_bad_inode();
     }
+
     mark_good_blocks();
     write_tables();
     return 0;
-
-}
+}

branches/2.2.5/mindi-busybox/util-linux/mkswap.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-/*
- * mkswap.c - set up a linux swap device
+/* mkswap.c - format swap device (Linux v1 only)
  *
- * (C) 1991 Linus Torvalds. This file may be redistributed as per
- * the Linux copyright.
+ * Copyright 2006 Rob Landley <rob@landley.net>
+ *
+ * Licensed under GPL version 2, see file LICENSE in this tarball for details.
  */
 
-/*
- * 20.12.91  -  time began. Got VM working yesterday by doing this by hand.
- *
- * Usage: mkswap [-c] [-vN] [-f] device [size-in-blocks]
- *
- *  -c   for readability checking. (Use it unless you are SURE!)
- *  -vN  for swap areas version N. (Only N=0,1 known today.)
- *      -f   for forcing swap creation even if it would smash partition table.
- *
- * The device may be a block device or an image of one, but this isn't
- * enforced (but it's not much fun on a character device :-).
- *
- * Patches from jaggy@purplet.demon.co.uk (Mike Jagdis) to make the
- * size-in-blocks parameter optional added Wed Feb  8 10:33:43 1995.
- *
- * Version 1 swap area code (for kernel 2.1.117), aeb, 981010.
- *
- * Sparc fixes, jj@ultra.linux.cz (Jakub Jelinek), 981201 - mangled by aeb.
- * V1_MAX_PAGES fixes, jj, 990325.
- *
- * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@misiek.eu.org>
- * - added Native Language Support
- *
- *  from util-linux -- adapted for busybox by
- *  Erik Andersen <andersen@codepoet.org>. I ripped out Native Language
- *  Support, made some stuff smaller, and fitted for life in busybox.
- *
- */
+#include "libbb.h"
 
-#include "busybox.h"
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>          /* for _IO */
-#include <sys/utsname.h>
-#include <asm/page.h>           /* for PAGE_SIZE and PAGE_SHIFT */
-                /* we also get PAGE_SIZE via getpagesize() */
-
-static char *device_name = NULL;
-static int DEV = -1;
-static long PAGES = 0;
-static int check = 0;
-static int badpages = 0;
-#if ENABLE_FEATURE_MKSWAP_V0
-static int version = -1;
-#else
-#define version 1
-/* and make sure that we optimize away anything which would deal with checking
- * the kernel revision as we have v1 support only anyway.
- */
-#undef KERNEL_VERSION
-#define KERNEL_VERSION(p,q,r) 1
-#define get_linux_version_code() 1
-#endif
-
-/*
- * The definition of the union swap_header uses the constant PAGE_SIZE.
- * Unfortunately, on some architectures this depends on the hardware model,
- * and can only be found at run time -- we use getpagesize().
- */
-
-static int pagesize;
-static unsigned int *signature_page;
-
-static struct swap_header_v1 {
-    char bootbits[1024];        /* Space for disklabel etc. */
-    unsigned int swap_version;
-    unsigned int last_page;
-    unsigned int nr_badpages;
-    unsigned int padding[125];
-    unsigned int badpages[1];
-} *p;
-
-static inline void init_signature_page(void)
-{
-    pagesize = getpagesize();
-
-#ifdef PAGE_SIZE
-    if (pagesize != PAGE_SIZE)
-        bb_error_msg("Assuming pages of size %d", pagesize);
-#endif
-    signature_page = (unsigned int *) xmalloc(pagesize);
-    memset(signature_page, 0, pagesize);
-    p = (struct swap_header_v1 *) signature_page;
-}
-
-static inline void write_signature(char *sig)
-{
-    char *sp = (char *) signature_page;
-
-    strncpy(sp + pagesize - 10, sig, 10);
-}
-
-#define V0_MAX_PAGES    (8 * (pagesize - 10))
-/* Before 2.2.0pre9 */
-#define V1_OLD_MAX_PAGES    ((0x7fffffff / pagesize) - 1)
-/* Since 2.2.0pre9:
-   error if nr of pages >= SWP_OFFSET(SWP_ENTRY(0,~0UL))
-   with variations on
-    #define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8))
-    #define SWP_OFFSET(entry) ((entry) >> 8)
-   on the various architectures. Below the result - yuk.
-
-   Machine  pagesize    SWP_ENTRY   SWP_OFFSET  bound+1 oldbound+2
-   i386     2^12        o<<8        e>>8        1<<24   1<<19
-   mips     2^12        o<<15       e>>15       1<<17   1<<19
-   alpha    2^13        o<<40       e>>40       1<<24   1<<18
-   m68k     2^12        o<<12       e>>12       1<<20   1<<19
-   sparc    2^{12,13}   (o&0x3ffff)<<9  (e>>9)&0x3ffff  1<<18   1<<{19,18}
-   sparc64  2^13        o<<13       e>>13       1<<51   1<<18
-   ppc      2^12        o<<8        e>>8        1<<24   1<<19
-   armo     2^{13,14,15}    o<<8        e>>8        1<<24   1<<{18,17,16}
-   armv     2^12        o<<9        e>>9        1<<23   1<<19
-
-   assuming that longs have 64 bits on alpha and sparc64 and 32 bits elsewhere.
-
-   The bad part is that we need to know this since the kernel will
-   refuse a swap space if it is too large.
-*/
-/* patch from jj - why does this differ from the above? */
-#if defined(__alpha__)
-#define V1_MAX_PAGES           ((1 << 24) - 1)
-#elif defined(__mips__)
-#define V1_MAX_PAGES           ((1 << 17) - 1)
-#elif defined(__sparc_v9__)
-#define V1_MAX_PAGES           ((3 << 29) - 1)
-#elif defined(__sparc__)
-#define V1_MAX_PAGES           (pagesize == 8192 ? ((3 << 29) - 1) : ((1 << 18) - 1))
-#else
-#define V1_MAX_PAGES           V1_OLD_MAX_PAGES
-#endif
-/* man page now says:
-The maximum useful size of a swap area now depends on the architecture.
-It is roughly 2GB on i386, PPC, m68k, ARM, 1GB on sparc, 512MB on mips,
-128GB on alpha and 3TB on sparc64.
-*/
-
-#define MAX_BADPAGES    ((pagesize-1024-128*sizeof(int)-10)/sizeof(int))
-
-static inline void bit_set(unsigned int *addr, unsigned int nr)
-{
-    unsigned int r, m;
-
-    addr += nr / (8 * sizeof(int));
-
-    r = *addr;
-    m = 1 << (nr & (8 * sizeof(int) - 1));
-
-    *addr = r | m;
-}
-
-static int bit_test_and_clear(unsigned int *addr, unsigned int nr)
-{
-    unsigned int r, m;
-
-    addr += nr / (8 * sizeof(int));
-
-    r = *addr;
-    m = 1 << (nr & (8 * sizeof(int) - 1));
-
-    *addr = r & ~m;
-    return (r & m) != 0;
-}
-
-static void page_ok(int page)
-{
-    if (ENABLE_FEATURE_MKSWAP_V0) {
-        bit_set(signature_page, page);
-    }
-}
-
-static void check_blocks(void)
-{
-    unsigned int current_page;
-    int do_seek = 1;
-    char *buffer;
-
-    buffer = xmalloc(pagesize);
-    current_page = 0;
-    while (current_page < PAGES) {
-        if (!check && version == 0) {
-            page_ok(current_page++);
-            continue;
-        }
-        if (do_seek && lseek(DEV, current_page * pagesize, SEEK_SET) !=
-            current_page * pagesize)
-            bb_error_msg_and_die("seek failed in check_blocks");
-        if ((do_seek = (pagesize != read(DEV, buffer, pagesize)))) {
-            current_page++;
-            if (version == 0)
-                bit_test_and_clear(signature_page, current_page);
-            else {
-                if (badpages == MAX_BADPAGES)
-                    bb_error_msg_and_die("too many bad pages");
-                p->badpages[badpages] = current_page;
-            }
-            badpages++;
-            continue;
-        }
-        page_ok(current_page++);
-    }
-    if (ENABLE_FEATURE_CLEAN_UP)
-        free(buffer);
-    if (badpages > 0)
-        printf("%d bad page%s\n", badpages, (badpages==1)?"":"s");
-}
-
-static long valid_offset(int fd, int offset)
-{
-    char ch;
-
-    if (lseek(fd, offset, 0) < 0)
-        return 0;
-    if (read(fd, &ch, 1) < 1)
-        return 0;
-    return 1;
-}
-
-static int find_size(int fd)
-{
-    unsigned int high, low;
-
-    low = 0;
-    for (high = 1; high > 0 && valid_offset(fd, high); high *= 2)
-        low = high;
-    while (low < high - 1) {
-        const int mid = (low + high) / 2;
-
-        if (valid_offset(fd, mid))
-            low = mid;
-        else
-            high = mid;
-    }
-    return (low + 1);
-}
-
-/* return size in pages, to avoid integer overflow */
-static inline long get_size(const char *file)
-{
-    int fd;
-    long size;
-
-    fd = bb_xopen3(file, O_RDONLY, 0);
-    if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
-        size /= pagesize / 512;
-    } else {
-        size = find_size(fd) / pagesize;
-    }
-    close(fd);
-    return size;
-}
-
+int mkswap_main(int argc, char **argv);
 int mkswap_main(int argc, char **argv)
 {
-    char *tmp;
-    struct stat statbuf;
-    int sz;
-    int maxpages;
-    int goodpages;
-#ifdef __sparc__
-    int force = 0;
-#endif
+    int fd, pagesize;
+    off_t len;
+    unsigned int hdr[129];
 
-    init_signature_page();      /* get pagesize */
+    // No options supported.
 
-    bb_opt_complementally = "?"; /* call bb_show_usage internally */
-    sz = bb_getopt_ulflags(argc, argv, "+cfv:", &tmp);
-    if (sz & 1)
-        check = 1;
-#ifdef __sparc__
-    if (sz & 2)
-        force = 1;
-#endif
-#if ENABLE_FEATURE_MKSWAP_V0
-    if (sz & 4) {
-        version = bb_xgetlarg(tmp, 10, 0, 1);
-    } else {
-        if (get_linux_version_code() < KERNEL_VERSION(2, 1, 117))
-            version = 0;
-        else
-            version = 1;
-    }
-#endif
+    if (argc != 2) bb_show_usage();
 
-    argv += optind;
-    argc -= optind;
+    // Figure out how big the device is and announce our intentions.
 
-    goodpages = pagesize / 1024; /* cache division */
-    while (argc--) {
-        if (device_name) {
-            PAGES = bb_xgetlarg(argv[0], 0, 10, sz * goodpages) / goodpages;
-            argc = 0; /* ignore any surplus args.. */
-        } else {
-            device_name = argv[0];
-            sz = get_size(device_name);
-            argv++;
-        }
-    }
+    fd = xopen(argv[1], O_RDWR);
+    len = fdlength(fd);
+    pagesize = getpagesize();
+    printf("Setting up swapspace version 1, size = %"OFF_FMT"d bytes\n",
+            len - pagesize);
 
-    if (!device_name) {
-        bb_error_msg_and_die("error: Nowhere to set up swap on?");
-    }
-    if (!PAGES) {
-        PAGES = sz;
-    }
+    // Make a header.
 
-#if 0
-    maxpages = ((version == 0) ? V0_MAX_PAGES : V1_MAX_PAGES);
-#else
-    if (!version)
-        maxpages = V0_MAX_PAGES;
-    else if (get_linux_version_code() >= KERNEL_VERSION(2,2,1))
-        maxpages = V1_MAX_PAGES;
-    else {
-        maxpages = V1_OLD_MAX_PAGES;
-        if (maxpages > V1_MAX_PAGES)
-            maxpages = V1_MAX_PAGES;
-    }
-#endif
-    if (PAGES > maxpages) {
-        PAGES = maxpages;
-        bb_error_msg("warning: truncating swap area to %ldkB",
-                PAGES * goodpages);
-    }
+    memset(hdr, 0, sizeof(hdr));
+    hdr[0] = 1;
+    hdr[1] = (len / pagesize) - 1;
 
-    DEV = bb_xopen3(device_name, O_RDWR, 0);
-    if (fstat(DEV, &statbuf) < 0)
-        bb_perror_msg_and_die("%s", device_name);
-    if (!S_ISBLK(statbuf.st_mode))
-        check = 0;
-    else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
-        bb_error_msg_and_die("Will not try to make swapdevice on '%s'", device_name);
+    // Write the header.  Sync to disk because some kernel versions check
+    // signature on disk (not in cache) during swapon.
 
-#ifdef __sparc__
-    if (!force && version == 0) {
-        /* Don't overwrite partition table unless forced */
-        unsigned char *buffer = (unsigned char *) signature_page;
-        unsigned short *q, sum;
+    xlseek(fd, 1024, SEEK_SET);
+    xwrite(fd, hdr, sizeof(hdr));
+    xlseek(fd, pagesize-10, SEEK_SET);
+    xwrite(fd, "SWAPSPACE2", 10);
+    fsync(fd);
 
-        if (read(DEV, buffer, 512) != 512)
-            bb_error_msg_and_die("fatal: first page unreadable");
-        if (buffer[508] == 0xDA && buffer[509] == 0xBE) {
-            q = (unsigned short *) (buffer + 510);
-            for (sum = 0; q >= (unsigned short *) buffer;)
-                sum ^= *q--;
-            if (!sum) {
-                bb_error_msg("Device '%s' contains a valid Sun disklabel.\n"
-"This probably means creating v0 swap would destroy your partition table\n"
-"No swap created. If you really want to create swap v0 on that device, use\n"
-"the -f option to force it.", device_name);
-                return EXIT_FAILURE;
-            }
-        }
-    }
-#endif
+    if (ENABLE_FEATURE_CLEAN_UP) close(fd);
 
-    if (version == 0 || check)
-        check_blocks();
-    if (version == 0 && !bit_test_and_clear(signature_page, 0))
-        bb_error_msg_and_die("fatal: first page unreadable");
-    if (version == 1) {
-        p->swap_version = version;
-        p->last_page = PAGES - 1;
-        p->nr_badpages = badpages;
-    }
-
-    goodpages = PAGES - badpages - 1;
-    if (goodpages <= 0)
-        bb_error_msg_and_die("Unable to set up swap-space: unreadable");
-    printf("Setting up swapspace version %d, size = %ld bytes\n",
-           version, (long) (goodpages * pagesize));
-    write_signature((version == 0) ? "SWAP-SPACE" : "SWAPSPACE2");
-
-    sz = ((version == 0) ? 0 : 1024); /* offset */
-    if (lseek(DEV, sz, SEEK_SET) != sz)
-        bb_error_msg_and_die("unable to rewind swap-device");
-    goodpages = pagesize - sz; /* cache substraction */
-    if (write(DEV, (char *) signature_page + sz, goodpages)
-        != goodpages)
-        bb_error_msg_and_die("unable to write signature page");
-
-    /*
-     * A subsequent swapon() will fail if the signature
-     * is not actually on disk. (This is a kernel bug.)
-     */
-    if (fsync(DEV))
-        bb_error_msg_and_die("fsync failed");
-    if (ENABLE_FEATURE_CLEAN_UP) {
-        close(DEV);
-        free(signature_page);
-    }
-    return EXIT_SUCCESS;
+    return 0;
 }

branches/2.2.5/mindi-busybox/util-linux/more.c

@@ -12 +12 @@
  * Termios corrects by Vladimir Oleynik <dzo@simtreas.ru>
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
+ * Licensed under GPLv2 or later, see file License in this tarball for details.
  */
 
-#include <stdio.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <sys/ioctl.h>
-#include "busybox.h"
-
-
-#ifdef CONFIG_FEATURE_USE_TERMIOS
-static int cin_fileno;
+#include "libbb.h"
+#if ENABLE_FEATURE_USE_TERMIOS
 #include <termios.h>
-#define setTermSettings(fd,argp) tcsetattr(fd,TCSANOW,argp)
-#define getTermSettings(fd,argp) tcgetattr(fd, argp);
-
-static struct termios initial_settings, new_settings;
-
-static void set_tty_to_initial_mode(void)
-{
-    setTermSettings(cin_fileno, &initial_settings);
-}
+#endif /* FEATURE_USE_TERMIOS */
+
+
+#if ENABLE_FEATURE_USE_TERMIOS
+
+struct globals {
+    int cin_fileno;
+    struct termios initial_settings;
+    struct termios new_settings;
+};
+#define G (*(struct globals*)bb_common_bufsiz1)
+//#define G (*ptr_to_globals)
+#define INIT_G() ((void)0)
+//#define INIT_G() PTR_TO_GLOBALS = xzalloc(sizeof(G))
+#define initial_settings (G.initial_settings)
+#define new_settings     (G.new_settings    )
+#define cin_fileno       (G.cin_fileno      )
+
+#define setTermSettings(fd, argp) tcsetattr(fd, TCSANOW, argp)
+#define getTermSettings(fd, argp) tcgetattr(fd, argp)
 
 static void gotsig(int sig)
 {
     putchar('\n');
+    setTermSettings(cin_fileno, &initial_settings);
     exit(EXIT_FAILURE);
 }
-#endif /* CONFIG_FEATURE_USE_TERMIOS */
-
-
+
+#else /* !FEATURE_USE_TERMIOS */
+#define INIT_G() ((void)0)
+#define setTermSettings(fd, argp) ((void)0)
+#endif /* FEATURE_USE_TERMIOS */
+
+#define CONVERTED_TAB_SIZE 8
+
+int more_main(int argc, char **argv);
 int more_main(int argc, char **argv)
 {
-    int c, lines, input = 0;
-    int please_display_more_prompt = 0;
+    int c = c; /* for gcc */
+    int lines;
+    int input = 0;
+    int spaces = 0;
+    int please_display_more_prompt;
     struct stat st;
     FILE *file;
     FILE *cin;
-    int len, page_height;
+    int len;
     int terminal_width;
     int terminal_height;
 
-    argc--;
+    INIT_G();
+
     argv++;
-
-
-    /* not use inputing from terminal if usage: more > outfile */
-    if(isatty(STDOUT_FILENO)) {
-        cin = fopen(CURRENT_TTY, "r");
-        if (!cin)
-            cin = bb_xfopen(CONSOLE_DEV, "r");
-        please_display_more_prompt = 2;
-#ifdef CONFIG_FEATURE_USE_TERMIOS
-        cin_fileno = fileno(cin);
-        getTermSettings(cin_fileno, &initial_settings);
-        new_settings = initial_settings;
-        new_settings.c_lflag &= ~ICANON;
-        new_settings.c_lflag &= ~ECHO;
-        new_settings.c_cc[VMIN] = 1;
-        new_settings.c_cc[VTIME] = 0;
-        setTermSettings(cin_fileno, &new_settings);
-        atexit(set_tty_to_initial_mode);
-        (void) signal(SIGINT, gotsig);
-        (void) signal(SIGQUIT, gotsig);
-        (void) signal(SIGTERM, gotsig);
+    /* Another popular pager, most, detects when stdout
+     * is not a tty and turns into cat. This makes sense. */
+    if (!isatty(STDOUT_FILENO))
+        return bb_cat(argv);
+    cin = fopen(CURRENT_TTY, "r");
+    if (!cin)
+        return bb_cat(argv);
+
+#if ENABLE_FEATURE_USE_TERMIOS
+    cin_fileno = fileno(cin);
+    getTermSettings(cin_fileno, &initial_settings);
+    new_settings = initial_settings;
+    new_settings.c_lflag &= ~ICANON;
+    new_settings.c_lflag &= ~ECHO;
+    new_settings.c_cc[VMIN] = 1;
+    new_settings.c_cc[VTIME] = 0;
+    setTermSettings(cin_fileno, &new_settings);
+    signal(SIGINT, gotsig);
+    signal(SIGQUIT, gotsig);
+    signal(SIGTERM, gotsig);
 #endif
-    } else {
-        cin = stdin;
-    }
 
     do {
-        if (argc == 0) {
-            file = stdin;
-        } else
-            file = bb_wfopen(*argv, "r");
-        if(file==0)
-            goto loop;
-
+        file = stdin;
+        if (*argv) {
+            file = fopen_or_warn(*argv, "r");
+            if (!file)
+                continue;
+        }
         st.st_size = 0;
         fstat(fileno(file), &st);
 
-        please_display_more_prompt &= ~1;
-
+        please_display_more_prompt = 0;
+        /* never returns w, h <= 1 */
         get_terminal_width_height(fileno(cin), &terminal_width, &terminal_height);
-        if (terminal_height > 4)
-            terminal_height -= 2;
-        if (terminal_width > 0)
-            terminal_width -= 1;
-
-        len=0;
+        terminal_height -= 1;
+
+        len = 0;
         lines = 0;
-        page_height = terminal_height;
-        while ((c = getc(file)) != EOF) {
-
-            if ((please_display_more_prompt & 3) == 3) {
+        while (spaces || (c = getc(file)) != EOF) {
+            int wrap;
+            if (spaces)
+                spaces--;
+ loop_top:
+            if (input != 'r' && please_display_more_prompt) {
                 len = printf("--More-- ");
-                if (file != stdin && st.st_size > 0) {
-#if _FILE_OFFSET_BITS == 64
-                    len += printf("(%d%% of %lld bytes)",
-                           (int) (100 * ((double) ftell(file) /
-                           (double) st.st_size)), (long long)st.st_size);
-#else
-                    len += printf("(%d%% of %ld bytes)",
-                           (int) (100 * ((double) ftell(file) /
-                           (double) st.st_size)), (long)st.st_size);
-#endif
+                if (st.st_size > 0) {
+                    len += printf("(%d%% of %"OFF_FMT"d bytes)",
+                        (int) (ftello(file)*100 / st.st_size),
+                        st.st_size);
                 }
-
                 fflush(stdout);
 
@@ -141 +128 @@
                  * to get input from the user.
                  */
-                input = getc(cin);
-#ifndef CONFIG_FEATURE_USE_TERMIOS
-                printf("\033[A"); /* up cursor */
+                for (;;) {
+                    input = getc(cin);
+                    input = tolower(input);
+#if !ENABLE_FEATURE_USE_TERMIOS
+                    printf("\033[A"); /* up cursor */
 #endif
-                /* Erase the "More" message */
-                putc('\r', stdout);
-                while (--len >= 0)
-                    putc(' ', stdout);
-                putc('\r', stdout);
-                len=0;
+                    /* Erase the last message */
+                    printf("\r%*s\r", len, "");
+
+                    /* Due to various multibyte escape
+                     * sequences, it's not ok to accept
+                     * any input as a command to scroll
+                     * the screen. We only allow known
+                     * commands, else we show help msg. */
+                    if (input == ' ' || input == '\n' || input == 'q' || input == 'r')
+                        break;
+                    len = printf("(Enter:next line Space:next page Q:quit R:show the rest)");
+                }
+                len = 0;
                 lines = 0;
-                page_height = terminal_height;
-                please_display_more_prompt &= ~1;
+                please_display_more_prompt = 0;
 
                 if (input == 'q')
                     goto end;
+
+                /* The user may have resized the terminal.
+                 * Re-read the dimensions. */
+#if ENABLE_FEATURE_USE_TERMIOS
+                get_terminal_width_height(cin_fileno, &terminal_width, &terminal_height);
+                terminal_height -= 1;
+#endif
             }
+
+            /* Crudely convert tabs into spaces, which are
+             * a bajillion times easier to deal with. */
+            if (c == '\t') {
+                spaces = CONVERTED_TAB_SIZE - 1;
+                c = ' ';
+            }
 
             /*
              * There are two input streams to worry about here:
              *
-             * c     : the character we are reading from the file being "mored"
-             * input : a character received from the keyboard
+             * c    : the character we are reading from the file being "mored"
+             * input: a character received from the keyboard
              *
              * If we hit a newline in the _file_ stream, we want to test and
@@ -169 +178 @@
              * allows the user to quit while in the middle of a file.
              */
-            if (c == '\n') {
-                /* increment by just one line if we are at
-                 * the end of this line */
-                if (input == '\n')
-                    please_display_more_prompt |= 1;
-                /* Adjust the terminal height for any overlap, so that
-                 * no lines get lost off the top. */
-                if (len >= terminal_width) {
-                    int quot, rem;
-                    quot = len / terminal_width;
-                    rem  = len - (quot * terminal_width);
-                    if (quot) {
-                        if (rem)
-                            page_height-=quot;
-                        else
-                            page_height-=(quot-1);
-                    }
-                }
-                if (++lines >= page_height) {
-                    please_display_more_prompt |= 1;
-                }
-                len=0;
+            wrap = (++len > terminal_width);
+            if (c == '\n' || wrap) {
+                /* Then outputting this character
+                 * will move us to a new line. */
+                if (++lines >= terminal_height || input == '\n')
+                    please_display_more_prompt = 1;
+                len = 0;
             }
-            /*
-             * If we just read a newline from the file being 'mored' and any
-             * key other than a return is hit, scroll by one page
-             */
-            putc(c, stdout);
-            len++;
+            if (c != '\n' && wrap) {
+                /* Then outputting this will also put a character on
+                 * the beginning of that new line. Thus we first want to
+                 * display the prompt (if any), so we skip the putchar()
+                 * and go back to the top of the loop, without reading
+                 * a new character. */
+                goto loop_top;
+            }
+            /* My small mind cannot fathom backspaces and UTF-8 */
+            putchar(c);
         }
         fclose(file);
         fflush(stdout);
-loop:
-        argv++;
-    } while (--argc > 0);
-  end:
+    } while (*argv && *++argv);
+ end:
+    setTermSettings(cin_fileno, &initial_settings);
     return 0;
 }

branches/2.2.5/mindi-busybox/util-linux/mount.c

@@ -10 +10 @@
  */
 
-/* todo:
- * bb_getopt_ulflags();
- */
-
 /* Design notes: There is no spec for mount.  Remind me to write one.
 
@@ -23 +19 @@
 */
 
-#include "busybox.h"
-#include <unistd.h>
-#include <errno.h>
-#include <string.h>
+#include "libbb.h"
 #include <mntent.h>
-#include <ctype.h>
-#include <fcntl.h>      // for CONFIG_FEATURE_MOUNT_LOOP
-#include <sys/ioctl.h>  // for CONFIG_FEATURE_MOUNT_LOOP
-
-// These two aren't always defined in old headers
-#ifndef MS_BIND
-#define MS_BIND     4096
+
+/* Needed for nfs support only... */
+#include <syslog.h>
+#include <sys/utsname.h>
+#undef TRUE
+#undef FALSE
+#include <rpc/rpc.h>
+#include <rpc/pmap_prot.h>
+#include <rpc/pmap_clnt.h>
+
+
+#if defined(__dietlibc__)
+/* 16.12.2006, Sampo Kellomaki (sampo@iki.fi)
+ * dietlibc-0.30 does not have implementation of getmntent_r() */
+/* OTOH: why we use getmntent_r instead of getmntent? TODO... */
+struct mntent *getmntent_r(FILE* stream, struct mntent* result, char* buffer, int bufsize)
+{
+    /* *** XXX FIXME WARNING: This hack is NOT thread safe. --Sampo */
+    struct mntent* ment = getmntent(stream);
+    memcpy(result, ment, sizeof(struct mntent));
+    return result;
+}
 #endif
-#ifndef MS_MOVE
-#define MS_MOVE     8192
-#endif
-#ifndef MS_SILENT
-#define MS_SILENT   32768
-#endif
+
 
 // Not real flags, but we want to be able to check for this.
-#define MOUNT_NOAUTO    (1<<29)
-#define MOUNT_SWAP      (1<<30)
+enum {
+    MOUNT_USERS  = (1<<28)*ENABLE_DESKTOP,
+    MOUNT_NOAUTO = (1<<29),
+    MOUNT_SWAP   = (1<<30),
+};
+// TODO: more "user" flag compatibility.
+// "user" option (from mount manpage):
+// Only the user that mounted a filesystem can unmount it again.
+// If any user should be able to unmount, then use users instead of user
+// in the fstab line.  The owner option is similar to the user option,
+// with the restriction that the user must be the owner of the special file.
+// This may be useful e.g. for /dev/fd if a login script makes
+// the console user owner of this device.
+
 /* Standard mount options (from -o options or --options), with corresponding
  * flags */
@@ -52 +67 @@
     const char *name;
     long flags;
-} static const mount_options[] = {
-    // NOP flags.
-
-    {"loop", 0},
-    {"defaults", 0},
-    {"quiet", 0},
-
-    // vfs flags
-
-    {"ro", MS_RDONLY},
-    {"rw", ~MS_RDONLY},
-    {"nosuid", MS_NOSUID},
-    {"suid", ~MS_NOSUID},
-    {"dev", ~MS_NODEV},
-    {"nodev", MS_NODEV},
-    {"exec", ~MS_NOEXEC},
-    {"noexec", MS_NOEXEC},
-    {"sync", MS_SYNCHRONOUS},
-    {"async", ~MS_SYNCHRONOUS},
-    {"atime", ~MS_NOATIME},
-    {"noatime", MS_NOATIME},
-    {"diratime", ~MS_NODIRATIME},
-    {"nodiratime", MS_NODIRATIME},
-    {"loud", ~MS_SILENT},
-
-    // action flags
-
-    {"remount", MS_REMOUNT},
-    {"bind", MS_BIND},
-    {"move", MS_MOVE},
-    {"noauto",MOUNT_NOAUTO},
-    {"swap",MOUNT_SWAP}
+} static mount_options[] = {
+    // MS_FLAGS set a bit.  ~MS_FLAGS disable that bit.  0 flags are NOPs.
+
+    USE_FEATURE_MOUNT_LOOP(
+        {"loop", 0},
+    )
+
+    USE_FEATURE_MOUNT_FSTAB(
+        {"defaults", 0},
+        /* {"quiet", 0}, - do not filter out, vfat wants to see it */
+        {"noauto", MOUNT_NOAUTO},
+        {"sw", MOUNT_SWAP},
+        {"swap", MOUNT_SWAP},
+        USE_DESKTOP({"user",  MOUNT_USERS},)
+        USE_DESKTOP({"users", MOUNT_USERS},)
+    )
+
+    USE_FEATURE_MOUNT_FLAGS(
+        // vfs flags
+        {"nosuid", MS_NOSUID},
+        {"suid", ~MS_NOSUID},
+        {"dev", ~MS_NODEV},
+        {"nodev", MS_NODEV},
+        {"exec", ~MS_NOEXEC},
+        {"noexec", MS_NOEXEC},
+        {"sync", MS_SYNCHRONOUS},
+        {"async", ~MS_SYNCHRONOUS},
+        {"atime", ~MS_NOATIME},
+        {"noatime", MS_NOATIME},
+        {"diratime", ~MS_NODIRATIME},
+        {"nodiratime", MS_NODIRATIME},
+        {"loud", ~MS_SILENT},
+
+        // action flags
+
+        {"bind", MS_BIND},
+        {"move", MS_MOVE},
+        {"shared", MS_SHARED},
+        {"slave", MS_SLAVE},
+        {"private", MS_PRIVATE},
+        {"unbindable", MS_UNBINDABLE},
+        {"rshared", MS_SHARED|MS_RECURSIVE},
+        {"rslave", MS_SLAVE|MS_RECURSIVE},
+        {"rprivate", MS_SLAVE|MS_RECURSIVE},
+        {"runbindable", MS_UNBINDABLE|MS_RECURSIVE},
+    )
+
+    // Always understood.
+
+    {"ro", MS_RDONLY},        // vfs flag
+    {"rw", ~MS_RDONLY},       // vfs flag
+    {"remount", MS_REMOUNT},  // action flag
 };
 
+
 /* Append mount options to string */
-static void append_mount_options(char **oldopts, char *newopts)
-{
-    if(*oldopts && **oldopts) {
-        char *temp=bb_xasprintf("%s,%s",*oldopts,newopts);
-        free(*oldopts);
-        *oldopts=temp;
+static void append_mount_options(char **oldopts, const char *newopts)
+{
+    if (*oldopts && **oldopts) {
+        /* do not insert options which are already there */
+        while (newopts[0]) {
+            char *p;
+            int len = strlen(newopts);
+            p = strchr(newopts, ',');
+            if (p) len = p - newopts;
+            p = *oldopts;
+            while (1) {
+                if (!strncmp(p, newopts, len)
+                 && (p[len]==',' || p[len]==0))
+                    goto skip;
+                p = strchr(p,',');
+                if (!p) break;
+                p++;
+            }
+            p = xasprintf("%s,%.*s", *oldopts, len, newopts);
+            free(*oldopts);
+            *oldopts = p;
+skip:
+            newopts += len;
+            while (newopts[0] == ',') newopts++;
+        }
     } else {
         if (ENABLE_FEATURE_CLEAN_UP) free(*oldopts);
-        *oldopts = bb_xstrdup(newopts);
+        *oldopts = xstrdup(newopts);
     }
 }
 
 /* Use the mount_options list to parse options into flags.
- * Return list of unrecognized options in *strflags if strflags!=NULL */
+ * Also return list of unrecognized options if unrecognized!=NULL */
 static int parse_mount_options(char *options, char **unrecognized)
 {
@@ -113 +168 @@
 
         // Find this option in mount_options
-        for (i = 0; i < (sizeof(mount_options) / sizeof(*mount_options)); i++) {
+        for (i = 0; i < ARRAY_SIZE(mount_options); i++) {
             if (!strcasecmp(mount_options[i].name, options)) {
                 long fl = mount_options[i].flags;
-                if(fl < 0) flags &= fl;
+                if (fl < 0) flags &= fl;
                 else flags |= fl;
                 break;
@@ -122 +177 @@
         }
         // If unrecognized not NULL, append unrecognized mount options */
-        if (unrecognized
-                && i == (sizeof(mount_options) / sizeof(*mount_options)))
-        {
+        if (unrecognized && i == ARRAY_SIZE(mount_options)) {
             // Add it to strflags, to pass on to kernel
             i = *unrecognized ? strlen(*unrecognized) : 0;
@@ -135 +188 @@
 
         // Advance to next option, or finish
-        if(comma) {
+        if (comma) {
             *comma = ',';
             options = ++comma;
@@ -148 +201 @@
 static llist_t *get_block_backed_filesystems(void)
 {
-    char *fs, *buf,
-         *filesystems[] = {"/etc/filesystems", "/proc/filesystems", 0};
+    static const char filesystems[2][sizeof("/proc/filesystems")] = {
+        "/etc/filesystems",
+        "/proc/filesystems",
+    };
+    char *fs, *buf;
     llist_t *list = 0;
     int i;
     FILE *f;
 
-    for(i = 0; filesystems[i]; i++) {
-        if(!(f = fopen(filesystems[i], "r"))) continue;
-
-        for(fs = buf = 0; (fs = buf = bb_get_chomped_line_from_file(f));
-            free(buf))
-        {
-            if(!strncmp(buf,"nodev",5) && isspace(buf[5])) continue;
-
-            while(isspace(*fs)) fs++;
-            if(*fs=='#' || *fs=='*') continue;
-            if(!*fs) continue;
-
-            llist_add_to_end(&list,bb_xstrdup(fs));
+    for (i = 0; i < 2; i++) {
+        f = fopen(filesystems[i], "r");
+        if (!f) continue;
+
+        while ((buf = xmalloc_getline(f)) != 0) {
+            if (!strncmp(buf, "nodev", 5) && isspace(buf[5]))
+                continue;
+            fs = skip_whitespace(buf);
+            if (*fs=='#' || *fs=='*' || !*fs) continue;
+
+            llist_add_to_end(&list, xstrdup(fs));
+            free(buf);
         }
         if (ENABLE_FEATURE_CLEAN_UP) fclose(f);
@@ -186 +241 @@
 
 #if ENABLE_FEATURE_MTAB_SUPPORT
-static int useMtab;
+static int useMtab = 1;
 static int fakeIt;
 #else
@@ -194 +249 @@
 
 // Perform actual mount of specific filesystem at specific location.
-
+// NB: mp->xxx fields may be trashed on exit
 static int mount_it_now(struct mntent *mp, int vfsflags, char *filteropts)
 {
-    int rc;
-
-    if (fakeIt) { return 0; }
+    int rc = 0;
+
+    if (fakeIt) goto mtab;
 
     // Mount, with fallback to read-only if necessary.
 
-    for(;;) {
+    for (;;) {
         rc = mount(mp->mnt_fsname, mp->mnt_dir, mp->mnt_type,
                 vfsflags, filteropts);
-        if(!rc || (vfsflags&MS_RDONLY) || (errno!=EACCES && errno!=EROFS))
+        if (!rc || (vfsflags&MS_RDONLY) || (errno!=EACCES && errno!=EROFS))
             break;
         bb_error_msg("%s is write-protected, mounting read-only",
@@ -220 +275 @@
     /* If the mount was successful, and we're maintaining an old-style
      * mtab file by hand, add the new entry to it now. */
-
-    if(ENABLE_FEATURE_MTAB_SUPPORT && useMtab && !rc) {
+ mtab:
+    if (ENABLE_FEATURE_MTAB_SUPPORT && useMtab && !rc && !(vfsflags & MS_REMOUNT)) {
+        char *fsname;
         FILE *mountTable = setmntent(bb_path_mtab_file, "a+");
         int i;
 
-        if(!mountTable)
-            bb_error_msg("No %s\n",bb_path_mtab_file);
+        if (!mountTable) {
+            bb_error_msg("no %s",bb_path_mtab_file);
+            goto ret;
+        }
 
         // Add vfs string flags
 
-        for(i=0; mount_options[i].flags != MS_REMOUNT; i++)
-            if (mount_options[i].flags > 0)
-                append_mount_options(&(mp->mnt_opts),
-// Shut up about the darn const.  It's not important.  I don't care.
-                        (char *)mount_options[i].name);
+        for (i=0; mount_options[i].flags != MS_REMOUNT; i++)
+            if (mount_options[i].flags > 0 && (mount_options[i].flags & vfsflags))
+                append_mount_options(&(mp->mnt_opts), mount_options[i].name);
 
         // Remove trailing / (if any) from directory we mounted on
 
-        i = strlen(mp->mnt_dir);
-        if(i>1 && mp->mnt_dir[i-1] == '/') mp->mnt_dir[i-1] = 0;
+        i = strlen(mp->mnt_dir) - 1;
+        if (i > 0 && mp->mnt_dir[i] == '/') mp->mnt_dir[i] = 0;
+
+        // Convert to canonical pathnames as needed
+
+        mp->mnt_dir = bb_simplify_path(mp->mnt_dir);
+        fsname = 0;
+        if (!mp->mnt_type || !*mp->mnt_type) { /* bind mount */
+            mp->mnt_fsname = fsname = bb_simplify_path(mp->mnt_fsname);
+            mp->mnt_type = (char*)"bind";
+        }
+        mp->mnt_freq = mp->mnt_passno = 0;
 
         // Write and close.
 
-        if(!mp->mnt_type || !*mp->mnt_type) mp->mnt_type="--bind";
         addmntent(mountTable, mp);
         endmntent(mountTable);
-        if (ENABLE_FEATURE_CLEAN_UP)
-            if(strcmp(mp->mnt_type,"--bind")) mp->mnt_type = 0;
-    }
-
+        if (ENABLE_FEATURE_CLEAN_UP) {
+            free(mp->mnt_dir);
+            free(fsname);
+        }
+    }
+ ret:
     return rc;
 }
 
-
-// Mount one directory.  Handles NFS, loopback, autobind, and filesystem type
-// detection.  Returns 0 for success, nonzero for failure.
-
+#if ENABLE_FEATURE_MOUNT_NFS
+
+/*
+ * Linux NFS mount
+ * Copyright (C) 1993 Rick Sladkey <jrs@world.std.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this tarball for details.
+ *
+ * Wed Feb  8 12:51:48 1995, biro@yggdrasil.com (Ross Biro): allow all port
+ * numbers to be specified on the command line.
+ *
+ * Fri, 8 Mar 1996 18:01:39, Swen Thuemmler <swen@uni-paderborn.de>:
+ * Omit the call to connect() for Linux version 1.3.11 or later.
+ *
+ * Wed Oct  1 23:55:28 1997: Dick Streefland <dick_streefland@tasking.com>
+ * Implemented the "bg", "fg" and "retry" mount options for NFS.
+ *
+ * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@misiek.eu.org>
+ * - added Native Language Support
+ *
+ * Modified by Olaf Kirch and Trond Myklebust for new NFS code,
+ * plus NFSv3 stuff.
+ */
+
+/* This is just a warning of a common mistake.  Possibly this should be a
+ * uclibc faq entry rather than in busybox... */
+#if defined(__UCLIBC__) && ! defined(__UCLIBC_HAS_RPC__)
+#error "You need to build uClibc with UCLIBC_HAS_RPC for NFS support."
+#endif
+
+#define MOUNTPORT 635
+#define MNTPATHLEN 1024
+#define MNTNAMLEN 255
+#define FHSIZE 32
+#define FHSIZE3 64
+
+typedef char fhandle[FHSIZE];
+
+typedef struct {
+    unsigned int fhandle3_len;
+    char *fhandle3_val;
+} fhandle3;
+
+enum mountstat3 {
+    MNT_OK = 0,
+    MNT3ERR_PERM = 1,
+    MNT3ERR_NOENT = 2,
+    MNT3ERR_IO = 5,
+    MNT3ERR_ACCES = 13,
+    MNT3ERR_NOTDIR = 20,
+    MNT3ERR_INVAL = 22,
+    MNT3ERR_NAMETOOLONG = 63,
+    MNT3ERR_NOTSUPP = 10004,
+    MNT3ERR_SERVERFAULT = 10006,
+};
+typedef enum mountstat3 mountstat3;
+
+struct fhstatus {
+    unsigned int fhs_status;
+    union {
+        fhandle fhs_fhandle;
+    } fhstatus_u;
+};
+typedef struct fhstatus fhstatus;
+
+struct mountres3_ok {
+    fhandle3 fhandle;
+    struct {
+        unsigned int auth_flavours_len;
+        char *auth_flavours_val;
+    } auth_flavours;
+};
+typedef struct mountres3_ok mountres3_ok;
+
+struct mountres3 {
+    mountstat3 fhs_status;
+    union {
+        mountres3_ok mountinfo;
+    } mountres3_u;
+};
+typedef struct mountres3 mountres3;
+
+typedef char *dirpath;
+
+typedef char *name;
+
+typedef struct mountbody *mountlist;
+
+struct mountbody {
+    name ml_hostname;
+    dirpath ml_directory;
+    mountlist ml_next;
+};
+typedef struct mountbody mountbody;
+
+typedef struct groupnode *groups;
+
+struct groupnode {
+    name gr_name;
+    groups gr_next;
+};
+typedef struct groupnode groupnode;
+
+typedef struct exportnode *exports;
+
+struct exportnode {
+    dirpath ex_dir;
+    groups ex_groups;
+    exports ex_next;
+};
+typedef struct exportnode exportnode;
+
+struct ppathcnf {
+    int pc_link_max;
+    short pc_max_canon;
+    short pc_max_input;
+    short pc_name_max;
+    short pc_path_max;
+    short pc_pipe_buf;
+    uint8_t pc_vdisable;
+    char pc_xxx;
+    short pc_mask[2];
+};
+typedef struct ppathcnf ppathcnf;
+
+#define MOUNTPROG 100005
+#define MOUNTVERS 1
+
+#define MOUNTPROC_NULL 0
+#define MOUNTPROC_MNT 1
+#define MOUNTPROC_DUMP 2
+#define MOUNTPROC_UMNT 3
+#define MOUNTPROC_UMNTALL 4
+#define MOUNTPROC_EXPORT 5
+#define MOUNTPROC_EXPORTALL 6
+
+#define MOUNTVERS_POSIX 2
+
+#define MOUNTPROC_PATHCONF 7
+
+#define MOUNT_V3 3
+
+#define MOUNTPROC3_NULL 0
+#define MOUNTPROC3_MNT 1
+#define MOUNTPROC3_DUMP 2
+#define MOUNTPROC3_UMNT 3
+#define MOUNTPROC3_UMNTALL 4
+#define MOUNTPROC3_EXPORT 5
+
+enum {
+#ifndef NFS_FHSIZE
+    NFS_FHSIZE = 32,
+#endif
+#ifndef NFS_PORT
+    NFS_PORT = 2049
+#endif
+};
+
+/*
+ * We want to be able to compile mount on old kernels in such a way
+ * that the binary will work well on more recent kernels.
+ * Thus, if necessary we teach nfsmount.c the structure of new fields
+ * that will come later.
+ *
+ * Moreover, the new kernel includes conflict with glibc includes
+ * so it is easiest to ignore the kernel altogether (at compile time).
+ */
+
+struct nfs2_fh {
+    char                    data[32];
+};
+struct nfs3_fh {
+    unsigned short          size;
+    unsigned char           data[64];
+};
+
+struct nfs_mount_data {
+    int     version;        /* 1 */
+    int     fd;         /* 1 */
+    struct nfs2_fh  old_root;       /* 1 */
+    int     flags;          /* 1 */
+    int     rsize;          /* 1 */
+    int     wsize;          /* 1 */
+    int     timeo;          /* 1 */
+    int     retrans;        /* 1 */
+    int     acregmin;       /* 1 */
+    int     acregmax;       /* 1 */
+    int     acdirmin;       /* 1 */
+    int     acdirmax;       /* 1 */
+    struct sockaddr_in addr;        /* 1 */
+    char        hostname[256];      /* 1 */
+    int     namlen;         /* 2 */
+    unsigned int    bsize;          /* 3 */
+    struct nfs3_fh  root;           /* 4 */
+};
+
+/* bits in the flags field */
+enum {
+    NFS_MOUNT_SOFT = 0x0001,    /* 1 */
+    NFS_MOUNT_INTR = 0x0002,    /* 1 */
+    NFS_MOUNT_SECURE = 0x0004,  /* 1 */
+    NFS_MOUNT_POSIX = 0x0008,   /* 1 */
+    NFS_MOUNT_NOCTO = 0x0010,   /* 1 */
+    NFS_MOUNT_NOAC = 0x0020,    /* 1 */
+    NFS_MOUNT_TCP = 0x0040,     /* 2 */
+    NFS_MOUNT_VER3 = 0x0080,    /* 3 */
+    NFS_MOUNT_KERBEROS = 0x0100,    /* 3 */
+    NFS_MOUNT_NONLM = 0x0200    /* 3 */
+};
+
+
+/*
+ * We need to translate between nfs status return values and
+ * the local errno values which may not be the same.
+ *
+ * Andreas Schwab <schwab@LS5.informatik.uni-dortmund.de>: change errno:
+ * "after #include <errno.h> the symbol errno is reserved for any use,
+ *  it cannot even be used as a struct tag or field name".
+ */
+
+#ifndef EDQUOT
+#define EDQUOT  ENOSPC
+#endif
+
+// Convert each NFSERR_BLAH into EBLAH
+
+static const struct {
+    int stat;
+    int errnum;
+} nfs_errtbl[] = {
+    {0,0}, {1,EPERM}, {2,ENOENT}, {5,EIO}, {6,ENXIO}, {13,EACCES}, {17,EEXIST},
+    {19,ENODEV}, {20,ENOTDIR}, {21,EISDIR}, {22,EINVAL}, {27,EFBIG},
+    {28,ENOSPC}, {30,EROFS}, {63,ENAMETOOLONG}, {66,ENOTEMPTY}, {69,EDQUOT},
+    {70,ESTALE}, {71,EREMOTE}, {-1,EIO}
+};
+
+static char *nfs_strerror(int status)
+{
+    int i;
+    static char buf[sizeof("unknown nfs status return value: ") + sizeof(int)*3];
+
+    for (i = 0; nfs_errtbl[i].stat != -1; i++) {
+        if (nfs_errtbl[i].stat == status)
+            return strerror(nfs_errtbl[i].errnum);
+    }
+    sprintf(buf, "unknown nfs status return value: %d", status);
+    return buf;
+}
+
+static bool_t xdr_fhandle(XDR *xdrs, fhandle objp)
+{
+    if (!xdr_opaque(xdrs, objp, FHSIZE))
+         return FALSE;
+    return TRUE;
+}
+
+static bool_t xdr_fhstatus(XDR *xdrs, fhstatus *objp)
+{
+    if (!xdr_u_int(xdrs, &objp->fhs_status))
+         return FALSE;
+    switch (objp->fhs_status) {
+    case 0:
+        if (!xdr_fhandle(xdrs, objp->fhstatus_u.fhs_fhandle))
+             return FALSE;
+        break;
+    default:
+        break;
+    }
+    return TRUE;
+}
+
+static bool_t xdr_dirpath(XDR *xdrs, dirpath *objp)
+{
+    if (!xdr_string(xdrs, objp, MNTPATHLEN))
+         return FALSE;
+    return TRUE;
+}
+
+static bool_t xdr_fhandle3(XDR *xdrs, fhandle3 *objp)
+{
+    if (!xdr_bytes(xdrs, (char **)&objp->fhandle3_val, (unsigned int *) &objp->fhandle3_len, FHSIZE3))
+         return FALSE;
+    return TRUE;
+}
+
+static bool_t xdr_mountres3_ok(XDR *xdrs, mountres3_ok *objp)
+{
+    if (!xdr_fhandle3(xdrs, &objp->fhandle))
+        return FALSE;
+    if (!xdr_array(xdrs, &(objp->auth_flavours.auth_flavours_val), &(objp->auth_flavours.auth_flavours_len), ~0,
+                sizeof (int), (xdrproc_t) xdr_int))
+        return FALSE;
+    return TRUE;
+}
+
+static bool_t xdr_mountstat3(XDR *xdrs, mountstat3 *objp)
+{
+    if (!xdr_enum(xdrs, (enum_t *) objp))
+         return FALSE;
+    return TRUE;
+}
+
+static bool_t xdr_mountres3(XDR *xdrs, mountres3 *objp)
+{
+    if (!xdr_mountstat3(xdrs, &objp->fhs_status))
+        return FALSE;
+    switch (objp->fhs_status) {
+    case MNT_OK:
+        if (!xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
+             return FALSE;
+        break;
+    default:
+        break;
+    }
+    return TRUE;
+}
+
+#define MAX_NFSPROT ((nfs_mount_version >= 4) ? 3 : 2)
+
+/*
+ * nfs_mount_version according to the sources seen at compile time.
+ */
+static int nfs_mount_version;
+static int kernel_version;
+
+/*
+ * Unfortunately, the kernel prints annoying console messages
+ * in case of an unexpected nfs mount version (instead of
+ * just returning some error).  Therefore we'll have to try
+ * and figure out what version the kernel expects.
+ *
+ * Variables:
+ *  KERNEL_NFS_MOUNT_VERSION: kernel sources at compile time
+ *  NFS_MOUNT_VERSION: these nfsmount sources at compile time
+ *  nfs_mount_version: version this source and running kernel can handle
+ */
+static void
+find_kernel_nfs_mount_version(void)
+{
+    if (kernel_version)
+        return;
+
+    nfs_mount_version = 4; /* default */
+
+    kernel_version = get_linux_version_code();
+    if (kernel_version) {
+        if (kernel_version < KERNEL_VERSION(2,1,32))
+            nfs_mount_version = 1;
+        else if (kernel_version < KERNEL_VERSION(2,2,18) ||
+                (kernel_version >= KERNEL_VERSION(2,3,0) &&
+                 kernel_version < KERNEL_VERSION(2,3,99)))
+            nfs_mount_version = 3;
+        /* else v4 since 2.3.99pre4 */
+    }
+}
+
+static struct pmap *
+get_mountport(struct sockaddr_in *server_addr,
+    long unsigned prog,
+    long unsigned version,
+    long unsigned proto,
+    long unsigned port)
+{
+    struct pmaplist *pmap;
+    static struct pmap p = {0, 0, 0, 0};
+
+    server_addr->sin_port = PMAPPORT;
+/* glibc 2.4 (still) has pmap_getmaps(struct sockaddr_in *).
+ * I understand it like "IPv6 for this is not 100% ready" */
+    pmap = pmap_getmaps(server_addr);
+
+    if (version > MAX_NFSPROT)
+        version = MAX_NFSPROT;
+    if (!prog)
+        prog = MOUNTPROG;
+    p.pm_prog = prog;
+    p.pm_vers = version;
+    p.pm_prot = proto;
+    p.pm_port = port;
+
+    while (pmap) {
+        if (pmap->pml_map.pm_prog != prog)
+            goto next;
+        if (!version && p.pm_vers > pmap->pml_map.pm_vers)
+            goto next;
+        if (version > 2 && pmap->pml_map.pm_vers != version)
+            goto next;
+        if (version && version <= 2 && pmap->pml_map.pm_vers > 2)
+            goto next;
+        if (pmap->pml_map.pm_vers > MAX_NFSPROT ||
+            (proto && p.pm_prot && pmap->pml_map.pm_prot != proto) ||
+            (port && pmap->pml_map.pm_port != port))
+            goto next;
+        memcpy(&p, &pmap->pml_map, sizeof(p));
+next:
+        pmap = pmap->pml_next;
+    }
+    if (!p.pm_vers)
+        p.pm_vers = MOUNTVERS;
+    if (!p.pm_port)
+        p.pm_port = MOUNTPORT;
+    if (!p.pm_prot)
+        p.pm_prot = IPPROTO_TCP;
+    return &p;
+}
+
+static int daemonize(void)
+{
+    int fd;
+    int pid = fork();
+    if (pid < 0) /* error */
+        return -errno;
+    if (pid > 0) /* parent */
+        return 0;
+    /* child */
+    fd = xopen(bb_dev_null, O_RDWR);
+    dup2(fd, 0);
+    dup2(fd, 1);
+    dup2(fd, 2);
+    while (fd > 2) close(fd--);
+    setsid();
+    openlog(applet_name, LOG_PID, LOG_DAEMON);
+    logmode = LOGMODE_SYSLOG;
+    return 1;
+}
+
+// TODO
+static inline int we_saw_this_host_before(const char *hostname)
+{
+    return 0;
+}
+
+/* RPC strerror analogs are terminally idiotic:
+ * *mandatory* prefix and \n at end.
+ * This hopefully helps. Usage:
+ * error_msg_rpc(clnt_*error*(" ")) */
+static void error_msg_rpc(const char *msg)
+{
+    int len;
+    while (msg[0] == ' ' || msg[0] == ':') msg++;
+    len = strlen(msg);
+    while (len && msg[len-1] == '\n') len--;
+    bb_error_msg("%.*s", len, msg);
+}
+
+// NB: mp->xxx fields may be trashed on exit
+static int nfsmount(struct mntent *mp, int vfsflags, char *filteropts)
+{
+    CLIENT *mclient;
+    char *hostname;
+    char *pathname;
+    char *mounthost;
+    struct nfs_mount_data data;
+    char *opt;
+    struct hostent *hp;
+    struct sockaddr_in server_addr;
+    struct sockaddr_in mount_server_addr;
+    int msock, fsock;
+    union {
+        struct fhstatus nfsv2;
+        struct mountres3 nfsv3;
+    } status;
+    int daemonized;
+    char *s;
+    int port;
+    int mountport;
+    int proto;
+    int bg;
+    int soft;
+    int intr;
+    int posix;
+    int nocto;
+    int noac;
+    int nolock;
+    int retry;
+    int tcp;
+    int mountprog;
+    int mountvers;
+    int nfsprog;
+    int nfsvers;
+    int retval;
+
+    find_kernel_nfs_mount_version();
+
+    daemonized = 0;
+    mounthost = NULL;
+    retval = ETIMEDOUT;
+    msock = fsock = -1;
+    mclient = NULL;
+
+    /* NB: hostname, mounthost, filteropts must be free()d prior to return */
+
+    filteropts = xstrdup(filteropts); /* going to trash it later... */
+
+    hostname = xstrdup(mp->mnt_fsname);
+    /* mount_main() guarantees that ':' is there */
+    s = strchr(hostname, ':');
+    pathname = s + 1;
+    *s = '\0';
+    /* Ignore all but first hostname in replicated mounts
+       until they can be fully supported. (mack@sgi.com) */
+    s = strchr(hostname, ',');
+    if (s) {
+        *s = '\0';
+        bb_error_msg("warning: multiple hostnames not supported");
+    }
+
+    server_addr.sin_family = AF_INET;
+    if (!inet_aton(hostname, &server_addr.sin_addr)) {
+        hp = gethostbyname(hostname);
+        if (hp == NULL) {
+            bb_herror_msg("%s", hostname);
+            goto fail;
+        }
+        if (hp->h_length > sizeof(struct in_addr)) {
+            bb_error_msg("got bad hp->h_length");
+            hp->h_length = sizeof(struct in_addr);
+        }
+        memcpy(&server_addr.sin_addr,
+                hp->h_addr, hp->h_length);
+    }
+
+    memcpy(&mount_server_addr, &server_addr, sizeof(mount_server_addr));
+
+    /* add IP address to mtab options for use when unmounting */
+
+    if (!mp->mnt_opts) { /* TODO: actually mp->mnt_opts is never NULL */
+        mp->mnt_opts = xasprintf("addr=%s", inet_ntoa(server_addr.sin_addr));
+    } else {
+        char *tmp = xasprintf("%s%saddr=%s", mp->mnt_opts,
+                    mp->mnt_opts[0] ? "," : "",
+                    inet_ntoa(server_addr.sin_addr));
+        free(mp->mnt_opts);
+        mp->mnt_opts = tmp;
+    }
+
+    /* Set default options.
+     * rsize/wsize (and bsize, for ver >= 3) are left 0 in order to
+     * let the kernel decide.
+     * timeo is filled in after we know whether it'll be TCP or UDP. */
+    memset(&data, 0, sizeof(data));
+    data.retrans    = 3;
+    data.acregmin   = 3;
+    data.acregmax   = 60;
+    data.acdirmin   = 30;
+    data.acdirmax   = 60;
+    data.namlen = NAME_MAX;
+
+    bg = 0;
+    soft = 0;
+    intr = 0;
+    posix = 0;
+    nocto = 0;
+    nolock = 0;
+    noac = 0;
+    retry = 10000;      /* 10000 minutes ~ 1 week */
+    tcp = 0;
+
+    mountprog = MOUNTPROG;
+    mountvers = 0;
+    port = 0;
+    mountport = 0;
+    nfsprog = 100003;
+    nfsvers = 0;
+
+    /* parse options */
+    if (filteropts) for (opt = strtok(filteropts, ","); opt; opt = strtok(NULL, ",")) {
+        char *opteq = strchr(opt, '=');
+        if (opteq) {
+            static const char options[] ALIGN1 =
+                /* 0 */ "rsize\0"
+                /* 1 */ "wsize\0"
+                /* 2 */ "timeo\0"
+                /* 3 */ "retrans\0"
+                /* 4 */ "acregmin\0"
+                /* 5 */ "acregmax\0"
+                /* 6 */ "acdirmin\0"
+                /* 7 */ "acdirmax\0"
+                /* 8 */ "actimeo\0"
+                /* 9 */ "retry\0"
+                /* 10 */ "port\0"
+                /* 11 */ "mountport\0"
+                /* 12 */ "mounthost\0"
+                /* 13 */ "mountprog\0"
+                /* 14 */ "mountvers\0"
+                /* 15 */ "nfsprog\0"
+                /* 16 */ "nfsvers\0"
+                /* 17 */ "vers\0"
+                /* 18 */ "proto\0"
+                /* 19 */ "namlen\0"
+                /* 20 */ "addr\0";
+            int val = xatoi_u(opteq + 1);
+            *opteq = '\0';
+            switch (index_in_strings(options, opt)) {
+            case 0: // "rsize"
+                data.rsize = val;
+                break;
+            case 1: // "wsize"
+                data.wsize = val;
+                break;
+            case 2: // "timeo"
+                data.timeo = val;
+                break;
+            case 3: // "retrans"
+                data.retrans = val;
+                break;
+            case 4: // "acregmin"
+                data.acregmin = val;
+                break;
+            case 5: // "acregmax"
+                data.acregmax = val;
+                break;
+            case 6: // "acdirmin"
+                data.acdirmin = val;
+                break;
+            case 7: // "acdirmax"
+                data.acdirmax = val;
+                break;
+            case 8: // "actimeo"
+                data.acregmin = val;
+                data.acregmax = val;
+                data.acdirmin = val;
+                data.acdirmax = val;
+                break;
+            case 9: // "retry"
+                retry = val;
+                break;
+            case 10: // "port"
+                port = val;
+                break;
+            case 11: // "mountport"
+                mountport = val;
+                break;
+            case 12: // "mounthost"
+                mounthost = xstrndup(opteq+1,
+                        strcspn(opteq+1," \t\n\r,"));
+                break;
+            case 13: // "mountprog"
+                mountprog = val;
+                break;
+            case 14: // "mountvers"
+                mountvers = val;
+                break;
+            case 15: // "nfsprog"
+                nfsprog = val;
+                break;
+            case 16: // "nfsvers"
+            case 17: // "vers"
+                nfsvers = val;
+                break;
+            case 18: // "proto"
+                if (!strncmp(opteq+1, "tcp", 3))
+                    tcp = 1;
+                else if (!strncmp(opteq+1, "udp", 3))
+                    tcp = 0;
+                else
+                    bb_error_msg("warning: unrecognized proto= option");
+                break;
+            case 19: // "namlen"
+                if (nfs_mount_version >= 2)
+                    data.namlen = val;
+                else
+                    bb_error_msg("warning: option namlen is not supported\n");
+                break;
+            case 20: // "addr" - ignore
+                break;
+            default:
+                bb_error_msg("unknown nfs mount parameter: %s=%d", opt, val);
+                goto fail;
+            }
+        }
+        else {
+            static const char options[] ALIGN1 =
+                "bg\0"
+                "fg\0"
+                "soft\0"
+                "hard\0"
+                "intr\0"
+                "posix\0"
+                "cto\0"
+                "ac\0"
+                "tcp\0"
+                "udp\0"
+                "lock\0";
+            int val = 1;
+            if (!strncmp(opt, "no", 2)) {
+                val = 0;
+                opt += 2;
+            }
+            switch (index_in_strings(options, opt)) {
+            case 0: // "bg"
+                bg = val;
+                break;
+            case 1: // "fg"
+                bg = !val;
+                break;
+            case 2: // "soft"
+                soft = val;
+                break;
+            case 3: // "hard"
+                soft = !val;
+                break;
+            case 4: // "intr"
+                intr = val;
+                break;
+            case 5: // "posix"
+                posix = val;
+                break;
+            case 6: // "cto"
+                nocto = !val;
+                break;
+            case 7: // "ac"
+                noac = !val;
+                break;
+            case 8: // "tcp"
+                tcp = val;
+                break;
+            case 9: // "udp"
+                tcp = !val;
+                break;
+            case 10: // "lock"
+                if (nfs_mount_version >= 3)
+                    nolock = !val;
+                else
+                    bb_error_msg("warning: option nolock is not supported");
+                break;
+            default:
+                bb_error_msg("unknown nfs mount option: %s%s", val ? "" : "no", opt);
+                goto fail;
+            }
+        }
+    }
+    proto = (tcp) ? IPPROTO_TCP : IPPROTO_UDP;
+
+    data.flags = (soft ? NFS_MOUNT_SOFT : 0)
+        | (intr ? NFS_MOUNT_INTR : 0)
+        | (posix ? NFS_MOUNT_POSIX : 0)
+        | (nocto ? NFS_MOUNT_NOCTO : 0)
+        | (noac ? NFS_MOUNT_NOAC : 0);
+    if (nfs_mount_version >= 2)
+        data.flags |= (tcp ? NFS_MOUNT_TCP : 0);
+    if (nfs_mount_version >= 3)
+        data.flags |= (nolock ? NFS_MOUNT_NONLM : 0);
+    if (nfsvers > MAX_NFSPROT || mountvers > MAX_NFSPROT) {
+        bb_error_msg("NFSv%d not supported", nfsvers);
+        goto fail;
+    }
+    if (nfsvers && !mountvers)
+        mountvers = (nfsvers < 3) ? 1 : nfsvers;
+    if (nfsvers && nfsvers < mountvers) {
+        mountvers = nfsvers;
+    }
+
+    /* Adjust options if none specified */
+    if (!data.timeo)
+        data.timeo = tcp ? 70 : 7;
+
+    data.version = nfs_mount_version;
+
+    if (vfsflags & MS_REMOUNT)
+        goto do_mount;
+
+    /*
+     * If the previous mount operation on the same host was
+     * backgrounded, and the "bg" for this mount is also set,
+     * give up immediately, to avoid the initial timeout.
+     */
+    if (bg && we_saw_this_host_before(hostname)) {
+        daemonized = daemonize(); /* parent or error */
+        if (daemonized <= 0) { /* parent or error */
+            retval = -daemonized;
+            goto ret;
+        }
+    }
+
+    /* create mount daemon client */
+    /* See if the nfs host = mount host. */
+    if (mounthost) {
+        if (mounthost[0] >= '0' && mounthost[0] <= '9') {
+            mount_server_addr.sin_family = AF_INET;
+            mount_server_addr.sin_addr.s_addr = inet_addr(hostname);
+        } else {
+            hp = gethostbyname(mounthost);
+            if (hp == NULL) {
+                bb_herror_msg("%s", mounthost);
+                goto fail;
+            } else {
+                if (hp->h_length > sizeof(struct in_addr)) {
+                    bb_error_msg("got bad hp->h_length?");
+                    hp->h_length = sizeof(struct in_addr);
+                }
+                mount_server_addr.sin_family = AF_INET;
+                memcpy(&mount_server_addr.sin_addr,
+                        hp->h_addr, hp->h_length);
+            }
+        }
+    }
+
+    /*
+     * The following loop implements the mount retries. When the mount
+     * times out, and the "bg" option is set, we background ourself
+     * and continue trying.
+     *
+     * The case where the mount point is not present and the "bg"
+     * option is set, is treated as a timeout. This is done to
+     * support nested mounts.
+     *
+     * The "retry" count specified by the user is the number of
+     * minutes to retry before giving up.
+     */
+    {
+        struct timeval total_timeout;
+        struct timeval retry_timeout;
+        struct pmap* pm_mnt;
+        time_t t;
+        time_t prevt;
+        time_t timeout;
+
+        retry_timeout.tv_sec = 3;
+        retry_timeout.tv_usec = 0;
+        total_timeout.tv_sec = 20;
+        total_timeout.tv_usec = 0;
+        timeout = time(NULL) + 60 * retry;
+        prevt = 0;
+        t = 30;
+retry:
+        /* be careful not to use too many CPU cycles */
+        if (t - prevt < 30)
+            sleep(30);
+
+        pm_mnt = get_mountport(&mount_server_addr,
+                mountprog,
+                mountvers,
+                proto,
+                mountport);
+        nfsvers = (pm_mnt->pm_vers < 2) ? 2 : pm_mnt->pm_vers;
+
+        /* contact the mount daemon via TCP */
+        mount_server_addr.sin_port = htons(pm_mnt->pm_port);
+        msock = RPC_ANYSOCK;
+
+        switch (pm_mnt->pm_prot) {
+        case IPPROTO_UDP:
+            mclient = clntudp_create(&mount_server_addr,
+                         pm_mnt->pm_prog,
+                         pm_mnt->pm_vers,
+                         retry_timeout,
+                         &msock);
+            if (mclient)
+                break;
+            mount_server_addr.sin_port = htons(pm_mnt->pm_port);
+            msock = RPC_ANYSOCK;
+        case IPPROTO_TCP:
+            mclient = clnttcp_create(&mount_server_addr,
+                         pm_mnt->pm_prog,
+                         pm_mnt->pm_vers,
+                         &msock, 0, 0);
+            break;
+        default:
+            mclient = 0;
+        }
+        if (!mclient) {
+            if (!daemonized && prevt == 0)
+                error_msg_rpc(clnt_spcreateerror(" "));
+        } else {
+            enum clnt_stat clnt_stat;
+            /* try to mount hostname:pathname */
+            mclient->cl_auth = authunix_create_default();
+
+            /* make pointers in xdr_mountres3 NULL so
+             * that xdr_array allocates memory for us
+             */
+            memset(&status, 0, sizeof(status));
+
+            if (pm_mnt->pm_vers == 3)
+                clnt_stat = clnt_call(mclient, MOUNTPROC3_MNT,
+                          (xdrproc_t) xdr_dirpath,
+                          (caddr_t) &pathname,
+                          (xdrproc_t) xdr_mountres3,
+                          (caddr_t) &status,
+                          total_timeout);
+            else
+                clnt_stat = clnt_call(mclient, MOUNTPROC_MNT,
+                          (xdrproc_t) xdr_dirpath,
+                          (caddr_t) &pathname,
+                          (xdrproc_t) xdr_fhstatus,
+                          (caddr_t) &status,
+                          total_timeout);
+
+            if (clnt_stat == RPC_SUCCESS)
+                goto prepare_kernel_data; /* we're done */
+            if (errno != ECONNREFUSED) {
+                error_msg_rpc(clnt_sperror(mclient, " "));
+                goto fail;  /* don't retry */
+            }
+            /* Connection refused */
+            if (!daemonized && prevt == 0) /* print just once */
+                error_msg_rpc(clnt_sperror(mclient, " "));
+            auth_destroy(mclient->cl_auth);
+            clnt_destroy(mclient);
+            mclient = 0;
+            close(msock);
+        }
+
+        /* Timeout. We are going to retry... maybe */
+
+        if (!bg)
+            goto fail;
+        if (!daemonized) {
+            daemonized = daemonize();
+            if (daemonized <= 0) { /* parent or error */
+                retval = -daemonized;
+                goto ret;
+            }
+        }
+        prevt = t;
+        t = time(NULL);
+        if (t >= timeout)
+            /* TODO error message */
+            goto fail;
+
+        goto retry;
+    }
+
+prepare_kernel_data:
+
+    if (nfsvers == 2) {
+        if (status.nfsv2.fhs_status != 0) {
+            bb_error_msg("%s:%s failed, reason given by server: %s",
+                hostname, pathname,
+                nfs_strerror(status.nfsv2.fhs_status));
+            goto fail;
+        }
+        memcpy(data.root.data,
+                (char *) status.nfsv2.fhstatus_u.fhs_fhandle,
+                NFS_FHSIZE);
+        data.root.size = NFS_FHSIZE;
+        memcpy(data.old_root.data,
+                (char *) status.nfsv2.fhstatus_u.fhs_fhandle,
+                NFS_FHSIZE);
+    } else {
+        fhandle3 *my_fhandle;
+        if (status.nfsv3.fhs_status != 0) {
+            bb_error_msg("%s:%s failed, reason given by server: %s",
+                hostname, pathname,
+                nfs_strerror(status.nfsv3.fhs_status));
+            goto fail;
+        }
+        my_fhandle = &status.nfsv3.mountres3_u.mountinfo.fhandle;
+        memset(data.old_root.data, 0, NFS_FHSIZE);
+        memset(&data.root, 0, sizeof(data.root));
+        data.root.size = my_fhandle->fhandle3_len;
+        memcpy(data.root.data,
+                (char *) my_fhandle->fhandle3_val,
+                my_fhandle->fhandle3_len);
+
+        data.flags |= NFS_MOUNT_VER3;
+    }
+
+    /* create nfs socket for kernel */
+
+    if (tcp) {
+        if (nfs_mount_version < 3) {
+            bb_error_msg("NFS over TCP is not supported");
+            goto fail;
+        }
+        fsock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    } else
+        fsock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+    if (fsock < 0) {
+        bb_perror_msg("nfs socket");
+        goto fail;
+    }
+    if (bindresvport(fsock, 0) < 0) {
+        bb_perror_msg("nfs bindresvport");
+        goto fail;
+    }
+    if (port == 0) {
+        server_addr.sin_port = PMAPPORT;
+        port = pmap_getport(&server_addr, nfsprog, nfsvers,
+                    tcp ? IPPROTO_TCP : IPPROTO_UDP);
+        if (port == 0)
+            port = NFS_PORT;
+    }
+    server_addr.sin_port = htons(port);
+
+    /* prepare data structure for kernel */
+
+    data.fd = fsock;
+    memcpy((char *) &data.addr, (char *) &server_addr, sizeof(data.addr));
+    strncpy(data.hostname, hostname, sizeof(data.hostname));
+
+    /* clean up */
+
+    auth_destroy(mclient->cl_auth);
+    clnt_destroy(mclient);
+    close(msock);
+
+    if (bg) {
+        /* We must wait until mount directory is available */
+        struct stat statbuf;
+        int delay = 1;
+        while (stat(mp->mnt_dir, &statbuf) == -1) {
+            if (!daemonized) {
+                daemonized = daemonize();
+                if (daemonized <= 0) { /* parent or error */
+                    retval = -daemonized;
+                    goto ret;
+                }
+            }
+            sleep(delay);   /* 1, 2, 4, 8, 16, 30, ... */
+            delay *= 2;
+            if (delay > 30)
+                delay = 30;
+        }
+    }
+
+do_mount: /* perform actual mount */
+
+    mp->mnt_type = (char*)"nfs";
+    retval = mount_it_now(mp, vfsflags, (char*)&data);
+    goto ret;
+
+fail:   /* abort */
+
+    if (msock != -1) {
+        if (mclient) {
+            auth_destroy(mclient->cl_auth);
+            clnt_destroy(mclient);
+        }
+        close(msock);
+    }
+    if (fsock != -1)
+        close(fsock);
+
+ret:
+    free(hostname);
+    free(mounthost);
+    free(filteropts);
+    return retval;
+}
+
+#else /* !ENABLE_FEATURE_MOUNT_NFS */
+
+/* Never called. Call should be optimized out. */
+int nfsmount(struct mntent *mp, int vfsflags, char *filteropts);
+
+#endif /* !ENABLE_FEATURE_MOUNT_NFS */
+
+// Mount one directory.  Handles CIFS, NFS, loopback, autobind, and filesystem
+// type detection.  Returns 0 for success, nonzero for failure.
+// NB: mp->xxx fields may be trashed on exit
 static int singlemount(struct mntent *mp, int ignore_busy)
 {
@@ -268 +1383 @@
     // Treat fstype "auto" as unspecified.
 
-    if (mp->mnt_type && !strcmp(mp->mnt_type,"auto")) mp->mnt_type = 0;
+    if (mp->mnt_type && strcmp(mp->mnt_type,"auto") == 0)
+        mp->mnt_type = 0;
+
+    // Might this be an CIFS filesystem?
+
+    if (ENABLE_FEATURE_MOUNT_CIFS
+     && (!mp->mnt_type || strcmp(mp->mnt_type,"cifs") == 0)
+     && (mp->mnt_fsname[0]=='/' || mp->mnt_fsname[0]=='\\')
+     && mp->mnt_fsname[0]==mp->mnt_fsname[1]
+    ) {
+        len_and_sockaddr *lsa;
+        char *ip, *dotted;
+        char *s;
+
+        rc = 1;
+        // Replace '/' with '\' and verify that unc points to "//server/share".
+
+        for (s = mp->mnt_fsname; *s; ++s)
+            if (*s == '/') *s = '\\';
+
+        // get server IP
+
+        s = strrchr(mp->mnt_fsname, '\\');
+        if (s <= mp->mnt_fsname+1) goto report_error;
+        *s = '\0';
+        lsa = host2sockaddr(mp->mnt_fsname+2, 0);
+        *s = '\\';
+        if (!lsa) goto report_error;
+
+        // insert ip=... option into string flags.
+
+        dotted = xmalloc_sockaddr2dotted_noport(&lsa->sa);
+        ip = xasprintf("ip=%s", dotted);
+        parse_mount_options(ip, &filteropts);
+
+        // compose new unc '\\server-ip\share'
+        // (s => slash after hostname)
+
+        mp->mnt_fsname = xasprintf("\\\\%s%s", dotted, s);
+
+        // lock is required
+        vfsflags |= MS_MANDLOCK;
+
+        mp->mnt_type = (char*)"cifs";
+        rc = mount_it_now(mp, vfsflags, filteropts);
+        if (ENABLE_FEATURE_CLEAN_UP) {
+            free(mp->mnt_fsname);
+            free(ip);
+            free(dotted);
+            free(lsa);
+        }
+        goto report_error;
+    }
 
     // Might this be an NFS filesystem?
 
-    if (ENABLE_FEATURE_MOUNT_NFS &&
-        (!mp->mnt_type || !strcmp(mp->mnt_type,"nfs")) &&
-        strchr(mp->mnt_fsname, ':') != NULL)
-    {
-        if (nfsmount(mp->mnt_fsname, mp->mnt_dir, &vfsflags, &filteropts, 1)) {
-            bb_perror_msg("nfsmount failed");
-            goto report_error;
-        } else {
-            // Strangely enough, nfsmount() doesn't actually mount() anything.
-            mp->mnt_type = "nfs";
-            rc = mount_it_now(mp, vfsflags, filteropts);
-            if (ENABLE_FEATURE_CLEAN_UP) free(filteropts);
-            
-            goto report_error;
-        }
+    if (ENABLE_FEATURE_MOUNT_NFS
+     && (!mp->mnt_type || !strcmp(mp->mnt_type, "nfs"))
+     && strchr(mp->mnt_fsname, ':') != NULL
+    ) {
+        rc = nfsmount(mp, vfsflags, filteropts);
+        goto report_error;
     }
 
     // Look at the file.  (Not found isn't a failure for remount, or for
     // a synthetic filesystem like proc or sysfs.)
-
-    if (stat(mp->mnt_fsname, &st));
-    else if (!(vfsflags & (MS_REMOUNT | MS_BIND | MS_MOVE))) {
+    // (We use stat, not lstat, in order to allow
+    // mount symlink_to_file_or_blkdev dir)
+
+    if (!stat(mp->mnt_fsname, &st)
+     && !(vfsflags & (MS_REMOUNT | MS_BIND | MS_MOVE))
+    ) {
         // Do we need to allocate a loopback device for it?
 
         if (ENABLE_FEATURE_MOUNT_LOOP && S_ISREG(st.st_mode)) {
             loopFile = bb_simplify_path(mp->mnt_fsname);
-            mp->mnt_fsname = 0;
-            switch(set_loop(&(mp->mnt_fsname), loopFile, 0)) {
-                case 0:
-                case 1:
-                    break;
-                default:
-                    bb_error_msg( errno == EPERM || errno == EACCES
-                        ? bb_msg_perm_denied_are_you_root
-                        : "Couldn't setup loop device");
-                    return errno;
+            mp->mnt_fsname = NULL; /* will receive malloced loop dev name */
+            if (set_loop(&(mp->mnt_fsname), loopFile, 0) < 0) {
+                if (errno == EPERM || errno == EACCES)
+                    bb_error_msg(bb_msg_perm_denied_are_you_root);
+                else
+                    bb_perror_msg("cannot setup loop device");
+                return errno;
             }
 
         // Autodetect bind mounts
 
-        } else if (S_ISDIR(st.st_mode) && !mp->mnt_type) vfsflags |= MS_BIND;
+        } else if (S_ISDIR(st.st_mode) && !mp->mnt_type)
+            vfsflags |= MS_BIND;
     }
 
@@ -320 +1479 @@
     if (mp->mnt_type || (vfsflags & (MS_REMOUNT | MS_BIND | MS_MOVE)))
         rc = mount_it_now(mp, vfsflags, filteropts);
-
-    // Loop through filesystem types until mount succeeds or we run out
-
     else {
+        // Loop through filesystem types until mount succeeds
+        // or we run out
 
         /* Initialize list of block backed filesystems.  This has to be
@@ -337 +1495 @@
         for (fl = fslist; fl; fl = fl->link) {
             mp->mnt_type = fl->data;
-
-            if (!(rc = mount_it_now(mp,vfsflags, filteropts))) break;
-
-            mp->mnt_type = 0;
-        }
-    }
-
-    if (ENABLE_FEATURE_CLEAN_UP) free(filteropts);
+            rc = mount_it_now(mp, vfsflags, filteropts);
+            if (!rc) break;
+        }
+    }
 
     // If mount failed, clean up loop file (if any).
@@ -355 +1509 @@
         }
     }
-report_error:
-    if (rc && errno == EBUSY && ignore_busy) rc = 0;
+
+ report_error:
+    if (ENABLE_FEATURE_CLEAN_UP)
+        free(filteropts);
+
+    if (rc && errno == EBUSY && ignore_busy)
+        rc = 0;
     if (rc < 0)
-        bb_perror_msg("Mounting %s on %s failed", mp->mnt_fsname, mp->mnt_dir);
+        bb_perror_msg("mounting %s on %s failed", mp->mnt_fsname, mp->mnt_dir);
 
     return rc;
@@ -366 +1525 @@
 // each directory to be mounted.
 
+static const char must_be_root[] ALIGN1 = "you must be root";
+
+int mount_main(int argc, char **argv);
 int mount_main(int argc, char **argv)
 {
-    char *cmdopts = bb_xstrdup(""), *fstabname, *fstype=0, *storage_path=0;
+    enum { OPT_ALL = 0x10 };
+
+    char *cmdopts = xstrdup(""), *fstype=0, *storage_path=0;
+    char *opt_o;
+    const char *fstabname;
     FILE *fstab;
-    int i, opt, all = FALSE, rc = 0;
+    int i, j, rc = 0;
+    unsigned opt;
     struct mntent mtpair[2], *mtcur = mtpair;
+    SKIP_DESKTOP(const int nonroot = 0;)
+    USE_DESKTOP( int nonroot = (getuid() != 0);)
 
     /* parse long options, like --bind and --move.  Note that -o option
      * and --option are synonymous.  Yes, this means --remount,rw works. */
 
-    for (i = opt = 0; i < argc; i++) {
+    for (i = j = 0; i < argc; i++) {
         if (argv[i][0] == '-' && argv[i][1] == '-') {
-            append_mount_options(&cmdopts,argv[i]+2);
-        } else argv[opt++] = argv[i];
-    }
-    argc = opt;
+            append_mount_options(&cmdopts, argv[i]+2);
+        } else argv[j++] = argv[i];
+    }
+    argv[j] = 0;
+    argc = j;
 
     // Parse remaining options
 
-    while ((opt = getopt(argc, argv, "o:t:rwavnf")) > 0) {
-        switch (opt) {
-            case 'o':
-                append_mount_options(&cmdopts, optarg);
-                break;
-            case 't':
-                fstype = optarg;
-                break;
-            case 'r':
-                append_mount_options(&cmdopts, "ro");
-                break;
-            case 'w':
-                append_mount_options(&cmdopts, "rw");
-                break;
-            case 'a':
-                all = TRUE;
-                break;
-            case 'n':
-                USE_FEATURE_MTAB_SUPPORT(useMtab = FALSE;)
-                break;
-            case 'f':
-                USE_FEATURE_MTAB_SUPPORT(fakeIt = FALSE;)
-                break;
-            case 'v':
-                break;      // ignore -v
-            default:
-                bb_show_usage();
-        }
-    }
+    opt = getopt32(argv, "o:t:rwanfvs", &opt_o, &fstype);
+    if (opt & 0x1) append_mount_options(&cmdopts, opt_o); // -o
+    //if (opt & 0x2) // -t
+    if (opt & 0x4) append_mount_options(&cmdopts, "ro"); // -r
+    if (opt & 0x8) append_mount_options(&cmdopts, "rw"); // -w
+    //if (opt & 0x10) // -a
+    if (opt & 0x20) USE_FEATURE_MTAB_SUPPORT(useMtab = 0); // -n
+    if (opt & 0x40) USE_FEATURE_MTAB_SUPPORT(fakeIt = 1); // -f
+    //if (opt & 0x80) // -v: verbose (ignore)
+    //if (opt & 0x100) // -s: sloppy (ignore)
+    argv += optind;
+    argc -= optind;
 
     // Three or more non-option arguments?  Die with a usage message.
 
-    if (optind-argc>2) bb_show_usage();
+    if (argc > 2) bb_show_usage();
 
     // If we have no arguments, show currently mounted filesystems
 
-    if (optind == argc) {
-        if (!all) {
+    if (!argc) {
+        if (!(opt & OPT_ALL)) {
             FILE *mountTable = setmntent(bb_path_mtab_file, "r");
 
-            if(!mountTable) bb_error_msg_and_die("No %s",bb_path_mtab_file);
-
-            while (getmntent_r(mountTable,mtpair,bb_common_bufsiz1,
+            if (!mountTable) bb_error_msg_and_die("no %s", bb_path_mtab_file);
+
+            while (getmntent_r(mountTable, mtpair, bb_common_bufsiz1,
                                 sizeof(bb_common_bufsiz1)))
             {
-                // Don't show rootfs.
-                if (!strcmp(mtpair->mnt_fsname, "rootfs")) continue;
+                // Don't show rootfs. FIXME: why??
+                // util-linux 2.12a happily shows rootfs...
+                //if (!strcmp(mtpair->mnt_fsname, "rootfs")) continue;
 
                 if (!fstype || !strcmp(mtpair->mnt_type, fstype))
@@ -441 +1595 @@
             return EXIT_SUCCESS;
         }
-    }
+    } else storage_path = bb_simplify_path(argv[0]);
 
     // When we have two arguments, the second is the directory and we can
@@ -447 +1601 @@
     // argument when we get it.
 
-    if (optind+2 == argc) {
-        mtpair->mnt_fsname = argv[optind];
-        mtpair->mnt_dir = argv[optind+1];
+    if (argc == 2) {
+        if (nonroot)
+            bb_error_msg_and_die(must_be_root);
+        mtpair->mnt_fsname = argv[0];
+        mtpair->mnt_dir = argv[1];
         mtpair->mnt_type = fstype;
         mtpair->mnt_opts = cmdopts;
@@ -456 +1612 @@
     }
 
-    // If we have at least one argument, it's the storage location
-
-    if (optind < argc) storage_path = bb_simplify_path(argv[optind]);
+    i = parse_mount_options(cmdopts, 0);
+    if (nonroot && (i & ~MS_SILENT)) // Non-root users cannot specify flags
+        bb_error_msg_and_die(must_be_root);
+
+    // If we have a shared subtree flag, don't worry about fstab or mtab.
+
+    if (ENABLE_FEATURE_MOUNT_FLAGS
+     && (i & (MS_SHARED | MS_PRIVATE | MS_SLAVE | MS_UNBINDABLE))
+    ) {
+        rc = mount("", argv[0], "", i, "");
+        if (rc) bb_perror_msg_and_die("%s", argv[0]);
+        goto clean_up;
+    }
 
     // Open either fstab or mtab
 
-    if (parse_mount_options(cmdopts,0) & MS_REMOUNT)
-        fstabname = (char *)bb_path_mtab_file;  // Again with the evil const.
-    else fstabname="/etc/fstab";
-
-    if (!(fstab=setmntent(fstabname,"r")))
-        bb_perror_msg_and_die("Cannot read %s",fstabname);
+    fstabname = "/etc/fstab";
+    if (i & MS_REMOUNT) {
+        fstabname = bb_path_mtab_file;
+    }
+    fstab = setmntent(fstabname, "r");
+    if (!fstab)
+        bb_perror_msg_and_die("cannot read %s", fstabname);
 
     // Loop through entries until we find what we're looking for.
 
-    memset(mtpair,0,sizeof(mtpair));
+    memset(mtpair, 0, sizeof(mtpair));
     for (;;) {
-        struct mntent *mtnext = mtpair + (mtcur==mtpair ? 1 : 0);
+        struct mntent *mtnext = (mtcur==mtpair ? mtpair+1 : mtpair);
 
         // Get next fstab entry
@@ -483 +1650 @@
             // Were we looking for something specific?
 
-            if (optind != argc) {
+            if (argc) {
 
                 // If we didn't find anything, complain.
 
                 if (!mtnext->mnt_fsname)
-                    bb_error_msg_and_die("Can't find %s in %s",
-                        argv[optind], fstabname);
+                    bb_error_msg_and_die("can't find %s in %s",
+                        argv[0], fstabname);
+
+                mtcur = mtnext;
+                if (nonroot) {
+                    // fstab must have "users" or "user"
+                    if (!(parse_mount_options(mtcur->mnt_opts, 0) & MOUNT_USERS))
+                        bb_error_msg_and_die(must_be_root);
+                }
 
                 // Mount the last thing we found.
 
-                mtcur = mtnext;
-                mtcur->mnt_opts=bb_xstrdup(mtcur->mnt_opts);
-                append_mount_options(&(mtcur->mnt_opts),cmdopts);
+                mtcur->mnt_opts = xstrdup(mtcur->mnt_opts);
+                append_mount_options(&(mtcur->mnt_opts), cmdopts);
                 rc = singlemount(mtcur, 0);
                 free(mtcur->mnt_opts);
@@ -506 +1679 @@
          * "proc") or a full path from root */
 
-        if (optind != argc) {
+        if (argc) {
 
             // Is this what we're looking for?
 
-            if(strcmp(argv[optind],mtcur->mnt_fsname) &&
-               strcmp(storage_path,mtcur->mnt_fsname) &&
-               strcmp(argv[optind],mtcur->mnt_dir) &&
-               strcmp(storage_path,mtcur->mnt_dir)) continue;
+            if (strcmp(argv[0], mtcur->mnt_fsname) &&
+               strcmp(storage_path, mtcur->mnt_fsname) &&
+               strcmp(argv[0], mtcur->mnt_dir) &&
+               strcmp(storage_path, mtcur->mnt_dir)) continue;
 
             // Remember this entry.  Something later may have overmounted
@@ -523 +1696 @@
 
         } else {
-
             // Do we need to match a filesystem type?
-            if (fstype && strcmp(mtcur->mnt_type,fstype)) continue;
+            if (fstype && match_fstype(mtcur, fstype)) continue;
 
             // Skip noauto and swap anyway.
 
-            if (parse_mount_options(mtcur->mnt_opts,0)
+            if (parse_mount_options(mtcur->mnt_opts, 0)
                 & (MOUNT_NOAUTO | MOUNT_SWAP)) continue;
 
+            // No, mount -a won't mount anything,
+            // even user mounts, for mere humans.
+
+            if (nonroot)
+                bb_error_msg_and_die(must_be_root);
+
             // Mount this thing.
 
+            // NFS mounts want this to be xrealloc-able
+            mtcur->mnt_opts = xstrdup(mtcur->mnt_opts);
             if (singlemount(mtcur, 1)) {
                 /* Count number of failed mounts */
                 rc++;
             }
+            free(mtcur->mnt_opts);
         }
     }

branches/2.2.5/mindi-busybox/util-linux/pivot_root.c

@@ -7 +7 @@
  *     regardless of the kernel being used.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPL version 2, see file LICENSE in this tarball for details.
  */
-#include <stdlib.h>
-#include <stdio.h>
-#include <errno.h>
-#include "busybox.h"
+#include "libbb.h"
 
 extern int pivot_root(const char * new_root,const char * put_old);
 
+int pivot_root_main(int argc, char **argv);
 int pivot_root_main(int argc, char **argv)
 {
-    if (argc != 3)
-    bb_show_usage();
+    if (argc != 3)
+        bb_show_usage();
 
-    if (pivot_root(argv[1],argv[2]) < 0)
-        bb_perror_msg_and_die("pivot_root");
+    if (pivot_root(argv[1], argv[2]) < 0) {
+        /* prints "pivot_root: <strerror text>" */
+        bb_perror_nomsg_and_die();
+    }
 
-    return EXIT_SUCCESS;
-
+    return EXIT_SUCCESS;
 }

branches/2.2.5/mindi-busybox/util-linux/rdate.c

@@ -9 +9 @@
 */
 
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netdb.h>
-#include <stdio.h>
-#include <string.h>
-#include <time.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <signal.h>
+#include "libbb.h"
 
-#include "busybox.h"
-
-
-static const int RFC_868_BIAS = 2208988800UL;
+enum { RFC_868_BIAS = 2208988800UL };
 
 static void socket_timeout(int sig)
@@ -32 +20 @@
 static time_t askremotedate(const char *host)
 {
-    unsigned long nett;
-    struct sockaddr_in s_in;
+    uint32_t nett;
     int fd;
-
-    bb_lookup_host(&s_in, host);
-    s_in.sin_port = bb_lookup_port("time", "tcp", 37);
 
     /* Add a timeout for dead or inaccessible servers */
@@ -43 +27 @@
     signal(SIGALRM, socket_timeout);
 
-    fd = xconnect(&s_in);
+    fd = create_and_connect_stream_or_die(host, bb_lookup_port("time", "tcp", 37));
 
     if (safe_read(fd, (void *)&nett, 4) != 4)    /* read time from server */
@@ -51 +35 @@
     /* convert from network byte order to local byte order.
      * RFC 868 time is the number of seconds
-     *  since 00:00 (midnight) 1 January 1900 GMT
-     *  the RFC 868 time 2,208,988,800 corresponds to 00:00  1 Jan 1970 GMT
-     * Subtract the RFC 868 time  to get Linux epoch
+     * since 00:00 (midnight) 1 January 1900 GMT
+     * the RFC 868 time 2,208,988,800 corresponds to 00:00  1 Jan 1970 GMT
+     * Subtract the RFC 868 time to get Linux epoch
      */
 
-    return(ntohl(nett) - RFC_868_BIAS);
+    return ntohl(nett) - RFC_868_BIAS;
 }
 
+int rdate_main(int argc, char **argv);
 int rdate_main(int argc, char **argv)
 {
@@ -64 +49 @@
     unsigned long flags;
 
-    bb_opt_complementally = "-1";
-    flags = bb_getopt_ulflags(argc, argv, "sp");
+    opt_complementary = "-1";
+    flags = getopt32(argv, "sp");
 
     remote_time = askremotedate(argv[optind]);
@@ -74 +59 @@
         time(&current_time);
         if (current_time == remote_time)
-            bb_error_msg("Current time matches remote time.");
+            bb_error_msg("current time matches remote time");
         else
             if (stime(&remote_time) < 0)
-                bb_perror_msg_and_die("Could not set time of day");
+                bb_perror_msg_and_die("cannot set time of day");
     }
 

branches/2.2.5/mindi-busybox/util-linux/readprofile.c

@@ +1 @@
+/* vi: set sw=4 ts=4: */
 /*
  *  readprofile.c - used to read /proc/profile
@@ -4 +5 @@
  *  Copyright (C) 1994,1996 Alessandro Rubini (rubini@ipvvis.unipv.it)
  *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
  */
 
@@ -44 +33 @@
  */
 
-#include <errno.h>
-#include <stdio.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
+#include "libbb.h"
 #include <sys/utsname.h>
 
-#include "busybox.h"
-
 #define S_LEN 128
 
 /* These are the defaults */
-static const char defaultmap[]="/boot/System.map";
-static const char defaultpro[]="/proc/profile";
-
+static const char defaultmap[] ALIGN1 = "/boot/System.map";
+static const char defaultpro[] ALIGN1 = "/proc/profile";
+
+int readprofile_main(int argc, char **argv);
 int readprofile_main(int argc, char **argv)
 {
     FILE *map;
-    int proFd;
-    const char *mapFile, *proFile, *mult=0;
-    unsigned long len=0, indx=1;
-    uint64_t add0=0;
+    const char *mapFile, *proFile, *mult = 0;
+    unsigned long indx = 1;
+    size_t len;
+    uint64_t add0 = 0;
     unsigned int step;
     unsigned int *buf, total, fn_len;
-    unsigned long long fn_add, next_add;          /* current and next address */
+    unsigned long long fn_add, next_add;     /* current and next address */
     char fn_name[S_LEN], next_name[S_LEN];   /* current and next name */
+    char mapline[S_LEN];
     char mode[8];
-    int c;
-    int optAll=0, optInfo=0, optReset=0, optVerbose=0, optNative=0;
-    int optBins=0, optSub=0;
-    char mapline[S_LEN];
-    int maplineno=1;
+    int optAll = 0, optInfo = 0, optReset = 0;
+    int optVerbose = 0, optNative = 0;
+    int optBins = 0, optSub = 0;
+    int maplineno = 1;
     int header_printed;
 
@@ -86 +67 @@
     mapFile = defaultmap;
 
-    while ((c = getopt(argc, argv, "M:m:np:itvarVbs")) != -1) {
-        switch(c) {
-        case 'm':
-            mapFile = optarg;
-            break;
-        case 'n':
-            optNative++;
-            break;
-        case 'p':
-            proFile = optarg;
-            break;
-        case 'a':
-            optAll++;
-            break;
-        case 'b':
-            optBins++;
-            break;
-        case 's':
-            optSub++;
-            break;
-        case 'i':
-            optInfo++;
-            break;
-        case 'M':
-            mult = optarg;
-            break;
-        case 'r':
-            optReset++;
-            break;
-        case 'v':
-            optVerbose++;
-            break;
-        default:
-            bb_show_usage();
-        }
-    }
+    opt_complementary = "nn:aa:bb:ss:ii:rr:vv";
+    getopt32(argv, "M:m:p:nabsirv",
+            &mult, &mapFile, &proFile,
+            &optNative, &optAll, &optBins, &optSub,
+            &optInfo, &optReset, &optVerbose);
 
     if (optReset || mult) {
@@ -131 +81 @@
          */
         if (mult) {
-            multiplier = strtoul(mult, 0, 10);
+            multiplier = xatoi_u(mult);
             to_write = sizeof(int);
         } else {
@@ -138 +88 @@
         }
 
-        fd = bb_xopen(defaultpro,O_WRONLY);
-
-        if (write(fd, &multiplier, to_write) != to_write)
+        fd = xopen(defaultpro, O_WRONLY);
+
+        if (full_write(fd, &multiplier, to_write) != to_write)
             bb_perror_msg_and_die("error writing %s", defaultpro);
 
@@ -150 +100 @@
      * Use an fd for the profiling buffer, to skip stdio overhead
      */
-
-    proFd = bb_xopen(proFile,O_RDONLY);
-
-    if (((int)(len=lseek(proFd,0,SEEK_END)) < 0)
-        || (lseek(proFd,0,SEEK_SET) < 0))
-        bb_perror_msg_and_die(proFile);
-
-    buf = xmalloc(len);
-
-    if (read(proFd,buf,len) != len)
-        bb_perror_msg_and_die(proFile);
-
-    close(proFd);
-
+    len = MAXINT(ssize_t);
+    buf = xmalloc_open_read_close(proFile, &len);
     if (!optNative) {
         int entries = len/sizeof(*buf);
-        int big = 0,small = 0,i;
+        int big = 0, small = 0, i;
         unsigned *p;
 
@@ -176 +114 @@
         }
         if (big > small) {
-            bb_error_msg("Assuming reversed byte order. "
-                "Use -n to force native byte order.");
+            bb_error_msg("assuming reversed byte order, "
+                "use -n to force native byte order");
             for (p = buf; p < buf+entries; p++)
                 for (i = 0; i < sizeof(*buf)/2; i++) {
@@ -198 +136 @@
     total = 0;
 
-    map = bb_xfopen(mapFile, "r");
-
-    while (fgets(mapline,S_LEN,map)) {
-        if (sscanf(mapline,"%llx %s %s",&fn_add,mode,fn_name) != 3)
+    map = xfopen(mapFile, "r");
+
+    while (fgets(mapline, S_LEN, map)) {
+        if (sscanf(mapline, "%llx %s %s", &fn_add, mode, fn_name) != 3)
             bb_error_msg_and_die("%s(%i): wrong map line",
                          mapFile, maplineno);
 
-        if (!strcmp(fn_name,"_stext")) /* only elf works like this */ {
+        if (!strcmp(fn_name, "_stext")) /* only elf works like this */ {
             add0 = fn_add;
             break;
@@ -218 +156 @@
      * Main loop.
      */
-    while (fgets(mapline,S_LEN,map)) {
+    while (fgets(mapline, S_LEN, map)) {
         unsigned int this = 0;
 
-        if (sscanf(mapline,"%llx %s %s",&next_add,mode,next_name) != 3)
+        if (sscanf(mapline, "%llx %s %s", &next_add, mode, next_name) != 3)
             bb_error_msg_and_die("%s(%i): wrong map line",
-                         mapFile, maplineno);
+                    mapFile, maplineno);
 
         header_printed = 0;
@@ -241 +179 @@
             if (optBins && (buf[indx] || optAll)) {
                 if (!header_printed) {
-                    printf ("%s:\n", fn_name);
+                    printf("%s:\n", fn_name);
                     header_printed = 1;
                 }
-                printf ("\t%"PRIx64"\t%u\n", (indx - 1)*step + add0, buf[indx]);
+                printf("\t%"PRIx64"\t%u\n", (indx - 1)*step + add0, buf[indx]);
             }
             this += buf[indx++];
@@ -252 +190 @@
         if (optBins) {
             if (optVerbose || this > 0)
-                printf ("  total\t\t\t\t%u\n", this);
+                printf("  total\t\t\t\t%u\n", this);
         } else if ((this || optAll) &&
                (fn_len = next_add-fn_add) != 0) {
             if (optVerbose)
                 printf("%016llx %-40s %6i %8.4f\n", fn_add,
-                       fn_name,this,this/(double)fn_len);
+                       fn_name, this, this/(double)fn_len);
             else
                 printf("%6i %-40s %8.4f\n",
-                       this,fn_name,this/(double)fn_len);
+                       this, fn_name, this/(double)fn_len);
             if (optSub) {
                 unsigned long long scan;
@@ -277 +215 @@
 
         fn_add = next_add;
-        strcpy(fn_name,next_name);
+        strcpy(fn_name, next_name);
 
         maplineno++;
@@ -288 +226 @@
     if (optVerbose)
         printf("%016x %-40s %6i %8.4f\n",
-               0,"total",total,total/(double)(fn_add-add0));
+               0, "total", total, total/(double)(fn_add-add0));
     else
         printf("%6i %-40s %8.4f\n",
-               total,"total",total/(double)(fn_add-add0));
+               total, "total", total/(double)(fn_add-add0));
 
     fclose(map);

branches/2.2.5/mindi-busybox/util-linux/setarch.c

@@ -8 +8 @@
 */
 
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <stdio.h>
 #include <sys/personality.h>
 
-#include "busybox.h"
+#include "libbb.h"
 
+int setarch_main(int ATTRIBUTE_UNUSED argc, char **argv);
 int setarch_main(int ATTRIBUTE_UNUSED argc, char **argv)
 {
@@ -46 +42 @@
 
         /* Try to execute the program */
-        execvp(argv[0], argv);
+        BB_EXECVP(argv[0], argv);
     }
 

branches/2.2.5/mindi-busybox/util-linux/swaponoff.c

@@ -5 +5 @@
  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
  *
- * Licensed under the GPL v2, see the file LICENSE in this tarball.
+ * Licensed under the GPL version 2, see the file LICENSE in this tarball.
  */
 
-#include "busybox.h"
+#include "libbb.h"
 #include <mntent.h>
-#include <dirent.h>
-#include <errno.h>
-#include <string.h>
 #include <sys/swap.h>
 
-
-static int swap_enable_disable(const char *device)
+static int swap_enable_disable(char *device)
 {
     int status;
@@ -23 +19 @@
     xstat(device, &st);
 
+#if ENABLE_DESKTOP
     /* test for holes */
     if (S_ISREG(st.st_mode))
         if (st.st_blocks * 512 < st.st_size)
-            bb_error_msg_and_die("swap file has holes");
+            bb_error_msg("warning: swap file has holes");
+#endif
 
-    if (bb_applet_name[5] == 'n')
+    if (applet_name[5] == 'n')
         status = swapon(device, 0);
     else
@@ -61 +59 @@
 }
 
-#define DO_ALL    0x01
-
+int swap_on_off_main(int argc, char **argv);
 int swap_on_off_main(int argc, char **argv)
 {
@@ -70 +67 @@
         bb_show_usage();
 
-    ret = bb_getopt_ulflags(argc, argv, "a");
-    if (ret & DO_ALL)
+    ret = getopt32(argv, "a");
+    if (ret)
         return do_em_all();
 
-    ret = 0;
+    /* ret = 0; redundant */
     while (*++argv)
         ret += swap_enable_disable(*argv);

branches/2.2.5/mindi-busybox/util-linux/switch_root.c

@@ -1 @@
-/* vi:set ts=4:*/
+/* vi: set sw=4 ts=4: */
 /* Copyright 2005 Rob Landley <rob@landley.net>
  *
  * Switch from rootfs to another filesystem as the root of the mount tree.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPL version 2, see file LICENSE in this tarball for details.
  */
 
-#include "busybox.h"
-#include <fcntl.h>
-#include <string.h>
+#include "libbb.h"
 #include <sys/vfs.h>
-#include <unistd.h>
 
 
@@ -28 +25 @@
 #endif
 
-dev_t rootdev;
+static dev_t rootdev;
 
 // Recursively delete contents of rootfs.
 
-static void delete_contents(char *directory)
+static void delete_contents(const char *directory)
 {
     DIR *dir;
@@ -39 +36 @@
 
     // Don't descend into other filesystems
-    if (lstat(directory,&st) || st.st_dev != rootdev) return;
+    if (lstat(directory, &st) || st.st_dev != rootdev) return;
 
     // Recursively delete the contents of directories.
     if (S_ISDIR(st.st_mode)) {
-        if((dir = opendir(directory))) {
+        dir = opendir(directory);
+        if (dir) {
             while ((d = readdir(dir))) {
-                char *newdir=d->d_name;
+                char *newdir = d->d_name;
 
                 // Skip . and ..
-                if(*newdir=='.' && (!newdir[1] || (newdir[1]=='.' && !newdir[2])))
+                if (*newdir=='.' && (!newdir[1] || (newdir[1]=='.' && !newdir[2])))
                     continue;
 
@@ -67 +65 @@
 }
 
-int switch_root_main(int argc, char *argv[])
+int switch_root_main(int argc, char **argv);
+int switch_root_main(int argc, char **argv)
 {
-    char *newroot, *console=NULL;
+    char *newroot, *console = NULL;
     struct stat st1, st2;
     struct statfs stfs;
@@ -75 +74 @@
     // Parse args (-c console)
 
-    bb_opt_complementally="-2";
-    bb_getopt_ulflags(argc,argv,"c:",&console);
+    opt_complementary = "-2";
+    getopt32(argv, "c:", &console);
+    argv += optind;
 
     // Change to new root directory and verify it's a different fs.
 
-    newroot=argv[optind++];
+    newroot = *argv++;
 
-    if (chdir(newroot) || lstat(".", &st1) || lstat("/", &st2) ||
-        st1.st_dev == st2.st_dev)
-    {
-        bb_error_msg_and_die("bad newroot %s",newroot);
+    xchdir(newroot);
+    if (lstat(".", &st1) || lstat("/", &st2) || st1.st_dev == st2.st_dev) {
+        bb_error_msg_and_die("bad newroot %s", newroot);
     }
-    rootdev=st2.st_dev;
+    rootdev = st2.st_dev;
 
     // Additional sanity checks: we're about to rm -rf /,  so be REALLY SURE
     // we mean it.  (I could make this a CONFIG option, but I would get email
-    // from all the people who WILL eat their filesystemss.)
+    // from all the people who WILL eat their filesystems.)
 
     if (lstat("/init", &st1) || !S_ISREG(st1.st_mode) || statfs("/", &stfs) ||
@@ -107 +106 @@
     // recalculate "." and ".." links.
 
-    if (mount(".", "/", NULL, MS_MOVE, NULL) || chroot(".") || chdir("/"))
-        bb_error_msg_and_die("moving root");
+    if (mount(".", "/", NULL, MS_MOVE, NULL) || chroot("."))
+        bb_error_msg_and_die("error moving root");
+    xchdir("/");
 
     // If a new console specified, redirect stdin/stdout/stderr to that.
@@ -114 +114 @@
     if (console) {
         close(0);
-        if(open(console, O_RDWR) < 0)
-            bb_error_msg_and_die("Bad console '%s'",console);
+        xopen(console, O_RDWR);
         dup2(0, 1);
         dup2(0, 2);
@@ -121 +120 @@
 
     // Exec real init.  (This is why we must be pid 1.)
-    execv(argv[optind],argv+optind);
-    bb_error_msg_and_die("Bad init '%s'",argv[optind]);
+    execv(argv[0], argv);
+    bb_perror_msg_and_die("bad init %s", argv[0]);
 }

branches/2.2.5/mindi-busybox/util-linux/umount.c

@@ -6 +6 @@
  * Copyright (C) 2005 by Rob Landley <rob@landley.net>
  *
- * This program is licensed under the GNU General Public license (GPL)
- * version 2 or later, see http://www.fsf.org/licensing/licenses/gpl.html
- * or the file "LICENSE" in the busybox source tarball for the full text.
- *
+ * Licensed under GPL version 2, see file LICENSE in this tarball for details.
  */
 
-#include "busybox.h"
 #include <mntent.h>
-#include <errno.h>
 #include <getopt.h>
+#include "libbb.h"
 
-#define OPTION_STRING       "flDnravd"
+#define OPTION_STRING       "flDnravdt:"
 #define OPT_FORCE           1
 #define OPT_LAZY            2
@@ -25 +21 @@
 #define OPT_ALL             (ENABLE_FEATURE_UMOUNT_ALL ? 32 : 0)
 
+int umount_main(int argc, char **argv);
 int umount_main(int argc, char **argv)
 {
@@ -31 +28 @@
     struct mntent me;
     FILE *fp;
+    char *fstype = 0;
     int status = EXIT_SUCCESS;
-    unsigned long opt;
+    unsigned opt;
     struct mtab_list {
         char *dir;
@@ -41 +39 @@
     /* Parse any options */
 
-    opt = bb_getopt_ulflags(argc, argv, OPTION_STRING);
+    opt = getopt32(argv, OPTION_STRING, &fstype);
 
     argc -= optind;
@@ -59 +57 @@
      * the argument list should be empty (which will match all). */
 
-    if (!(fp = setmntent(bb_path_mtab_file, "r"))) {
+    fp = setmntent(bb_path_mtab_file, "r");
+    if (!fp) {
         if (opt & OPT_ALL)
-            bb_error_msg_and_die("Cannot open %s", bb_path_mtab_file);
-    } else while (getmntent_r(fp,&me,path,sizeof(path))) {
-        m = xmalloc(sizeof(struct mtab_list));
-        m->next = mtl;
-        m->device = bb_xstrdup(me.mnt_fsname);
-        m->dir = bb_xstrdup(me.mnt_dir);
-        mtl = m;
+            bb_error_msg_and_die("cannot open %s", bb_path_mtab_file);
+    } else {
+        while (getmntent_r(fp, &me, path, sizeof(path))) {
+            /* Match fstype if passed */
+            if (fstype && match_fstype(&me, fstype))
+                continue;
+            m = xmalloc(sizeof(struct mtab_list));
+            m->next = mtl;
+            m->device = xstrdup(me.mnt_fsname);
+            m->dir = xstrdup(me.mnt_dir);
+            mtl = m;
+        }
+        endmntent(fp);
     }
-    endmntent(fp);
 
-    /* If we're not mounting all, we need at least one argument. */
-    if (!(opt & OPT_ALL)) {
+    /* If we're not umounting all, we need at least one argument. */
+    if (!(opt & OPT_ALL) && !fstype) {
         m = 0;
         if (!argc) bb_show_usage();
     }
-    
+
     // Loop through everything we're supposed to umount, and do so.
     for (;;) {
@@ -107 +111 @@
             curstat = umount2(zapit, doForce);
             if (curstat)
-                bb_error_msg_and_die("forced umount of %s failed!", zapit);
+                bb_error_msg("forced umount of %s failed!", zapit);
         }
 
@@ -113 +117 @@
         if (curstat && (opt & OPT_REMOUNT) && errno == EBUSY && m) {
             curstat = mount(m->device, zapit, NULL, MS_REMOUNT|MS_RDONLY, NULL);
-            bb_error_msg(curstat ? "Cannot remount %s read-only" :
+            bb_error_msg(curstat ? "cannot remount %s read-only" :
                          "%s busy - remounted read-only", m->device);
         }
@@ -119 +123 @@
         if (curstat) {
             status = EXIT_FAILURE;
-            bb_perror_msg("Couldn't umount %s", zapit);
+            bb_perror_msg("cannot umount %s", zapit);
         } else {
             /* De-allocate the loop device.  This ioctl should be ignored on
@@ -133 +137 @@
         // of /dev/blah, not just the most recent.
         while (m && (m = m->next))
-            if ((opt & OPT_ALL) || !strcmp(path,m->device))
+            if ((opt & OPT_ALL) || !strcmp(path, m->device))
                 break;
     }
@@ -145 +149 @@
             free(mtl->dir);
             free(mtl);
-            mtl=m;
+            mtl = m;
         }
     }