Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/miscutils

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

Location:

branches/2.2.9/mindi-busybox/miscutils

Files:

• Config.in (modified) (24 diffs)
• Config.src (added)
• Kbuild (modified) (3 diffs)
• Kbuild.src (added)
• adjtimex.c (modified) (7 diffs)
• bbconfig.c (modified) (1 diff)
• beep.c (added)
• chat.c (added)
• chrt.c (modified) (5 diffs)
• conspy.c (added)
• crond.c (modified) (11 diffs)
• crontab.c (modified) (1 diff)
• dc.c (modified) (11 diffs)
• devfsd.c (modified) (36 diffs)
• devmem.c (added)
• eject.c (modified) (3 diffs)
• fbsplash.c (added)
• fbsplash.cfg (added)
• flash_eraseall.c (added)
• flash_lock_unlock.c (added)
• flashcp.c (added)
• hdparm.c (modified) (68 diffs)
• inotifyd.c (added)
• ionice.c (added)
• last.c (modified) (4 diffs)
• last_fancy.c (added)
• less.c (modified) (67 diffs)
• makedevs.c (modified) (4 diffs)
• man.c (added)
• microcom.c (added)
• mountpoint.c (modified) (2 diffs)
• mt.c (modified) (3 diffs)
• nandwrite.c (added)
• raidautorun.c (modified) (2 diffs)
• readahead.c (modified) (1 diff)
• rfkill.c (added)
• runlevel.c (modified) (1 diff)
• rx.c (modified) (7 diffs)
• setsid.c (modified) (2 diffs)
• strings.c (modified) (3 diffs)
• taskset.c (modified) (1 diff)
• time.c (modified) (17 diffs)
• timeout.c (added)
• ttysize.c (modified) (3 diffs)
• ubi_attach_detach.c (added)
• volname.c (added)
• wall.c (added)
• watchdog.c (modified) (1 diff)

branches/2.2.9/mindi-busybox/miscutils/Config.in

@@ +1 @@
+# DO NOT EDIT. This file is generated from Config.src
 #
 # For a description of the syntax of this configuration file,
@@ -6 +7 @@
 menu "Miscellaneous Utilities"
 
+config CONSPY
+    bool "conspy"
+    default n
+    depends on PLATFORM_LINUX
+    help
+      A text-mode VNC like program for Linux virtual terminals.
+      example:  conspy NUM      shared access to console num
+      or        conspy -nd NUM  screenshot of console num
+      or        conspy -cs NUM  poor man's GNU screen like
+config NANDWRITE
+    bool "nandwrite"
+    default n
+    depends on PLATFORM_LINUX
+    help
+      Write to the specified MTD device, with bad blocks awareness
+
+config NANDDUMP
+    bool "nanddump"
+    default n
+    depends on PLATFORM_LINUX
+    help
+      Dump the content of raw NAND chip
+config UBIATTACH
+    bool "ubiattach"
+    default n
+    depends on PLATFORM_LINUX
+    help
+      Attach MTD device to an UBI device.
+
+config UBIDETACH
+    bool "ubidetach"
+    default n
+    depends on PLATFORM_LINUX
+    help
+      Detach MTD device from an UBI device.
+
 config ADJTIMEX
     bool "adjtimex"
-    default n
+    default y
+    depends on PLATFORM_LINUX
     help
       Adjtimex reads and optionally sets adjustment parameters for
@@ -20 +58 @@
       busybox was built.
 
+config FEATURE_COMPRESS_BBCONFIG
+    bool "Compress bbconfig data"
+    default y
+    depends on BBCONFIG
+    help
+      Store bbconfig data in compressed form, uncompress them on-the-fly
+      before output.
+
+      If you have a really tiny busybox with few applets enabled (and
+      bunzip2 isn't one of them), the overhead of the decompressor might
+      be noticeable. Also, if you run executables directly from ROM
+      and have very little memory, this might not be a win. Otherwise,
+      you probably want this.
+
+config BEEP
+    bool "beep"
+    default y
+    depends on PLATFORM_LINUX
+    help
+      The beep applets beeps in a given freq/Hz.
+
+config FEATURE_BEEP_FREQ
+    int "default frequency"
+    range 0 2147483647
+    default 4000
+    depends on BEEP
+    help
+      Frequency for default beep.
+
+config FEATURE_BEEP_LENGTH_MS
+    int "default length"
+    range 0 2147483647
+    default 30
+    depends on BEEP
+    help
+      Length in ms for default beep.
+
+config CHAT
+    bool "chat"
+    default y
+    help
+      Simple chat utility.
+
+config FEATURE_CHAT_NOFAIL
+    bool "Enable NOFAIL expect strings"
+    depends on CHAT
+    default y
+    help
+      When enabled expect strings which are started with a dash trigger
+      no-fail mode. That is when expectation is not met within timeout
+      the script is not terminated but sends next SEND string and waits
+      for next EXPECT string. This allows to compose far more flexible
+      scripts.
+
+config FEATURE_CHAT_TTY_HIFI
+    bool "Force STDIN to be a TTY"
+    depends on CHAT
+    default n
+    help
+      Original chat always treats STDIN as a TTY device and sets for it
+      so-called raw mode. This option turns on such behaviour.
+
+config FEATURE_CHAT_IMPLICIT_CR
+    bool "Enable implicit Carriage Return"
+    depends on CHAT
+    default y
+    help
+      When enabled make chat to terminate all SEND strings with a "\r"
+      unless "\c" is met anywhere in the string.
+
+config FEATURE_CHAT_SWALLOW_OPTS
+    bool "Swallow options"
+    depends on CHAT
+    default y
+    help
+      Busybox chat require no options. To make it not fail when used
+      in place of original chat (which has a bunch of options) turn
+      this on.
+
+config FEATURE_CHAT_SEND_ESCAPES
+    bool "Support weird SEND escapes"
+    depends on CHAT
+    default y
+    help
+      Original chat uses some escape sequences in SEND arguments which
+      are not sent to device but rather performs special actions.
+      E.g. "\K" means to send a break sequence to device.
+      "\d" delays execution for a second, "\p" -- for a 1/100 of second.
+      Before turning this option on think twice: do you really need them?
+
+config FEATURE_CHAT_VAR_ABORT_LEN
+    bool "Support variable-length ABORT conditions"
+    depends on CHAT
+    default y
+    help
+      Original chat uses fixed 50-bytes length ABORT conditions. Say N here.
+
+config FEATURE_CHAT_CLR_ABORT
+    bool "Support revoking of ABORT conditions"
+    depends on CHAT
+    default y
+    help
+      Support CLR_ABORT directive.
+
 config CHRT
     bool "chrt"
-    default n
+    default y
     help
       manipulate real-time attributes of a process.
@@ -29 +171 @@
 config CROND
     bool "crond"
-    default n
-    select FEATURE_SUID
+    default y
     select FEATURE_SYSLOG
     help
       Crond is a background daemon that parses individual crontab
       files and executes commands on behalf of the users in question.
-      This is a port of dcron from slackware.  It uses files of the
+      This is a port of dcron from slackware. It uses files of the
       format /var/spool/cron/crontabs/<username> files, for example:
           $ cat /var/spool/cron/crontabs/root
           # Run daily cron jobs at 4:40 every day:
           40 4 * * * /etc/cron/daily > /dev/null 2>&1
+
+config FEATURE_CROND_D
+    bool "Support option -d to redirect output to stderr"
+    depends on CROND
+    default y
+    help
+      -d sets loglevel to 0 (most verbose) and directs all output to stderr.
+
+config FEATURE_CROND_CALL_SENDMAIL
+    bool "Report command output via email (using sendmail)"
+    default y
+    depends on CROND
+    help
+      Command output will be sent to corresponding user via email.
+
+config FEATURE_CROND_DIR
+    string "crond spool directory"
+    default "/var/spool/cron"
+    depends on CROND || CRONTAB
+    help
+      Location of crond spool.
+
+config CRONTAB
+    bool "crontab"
+    default y
+    help
+      Crontab manipulates the crontab for a particular user. Only
+      the superuser may specify a different user and/or crontab directory.
       Note that Busybox binary must be setuid root for this applet to
       work properly.
 
-config DEBUG_CROND_OPTION
-    bool "Support debug option -d"
-    depends on CROND
-    default n
-    help
-      Support option -d to enter debug mode.
-
-config FEATURE_CROND_CALL_SENDMAIL
-    bool "Using /usr/sbin/sendmail?"
-    default n
-    depends on CROND
-    help
-      Support calling /usr/sbin/sendmail for send cmd outputs.
-
-config CRONTAB
-    bool "crontab"
-    default n
-    select FEATURE_SUID
-    help
-      Crontab manipulates the crontab for a particular user.  Only
-      the superuser may specify a different user and/or crontab directory.
-
 config DC
     bool "dc"
-    default n
+    default y
     help
       Dc is a reverse-polish desk calculator which supports unlimited
       precision arithmetic.
 
+config FEATURE_DC_LIBM
+    bool "Enable power and exp functions (requires libm)"
+    default y
+    depends on DC
+    help
+      Enable power and exp functions.
+      NOTE: This will require libm to be present for linking.
+
 config DEVFSD
     bool "devfsd (obsolete)"
     default n
+    depends on PLATFORM_LINUX
     select FEATURE_SYSLOG
     help
-      This is deprecated, and will be removed at the end of 2008.
+      This is deprecated and should NOT be used anymore.
+      Use linux >= 2.6 (optionally with hotplug) and mdev instead!
+      See docs/mdev.txt for detailed instructions on how to use mdev
+      instead.
 
       Provides compatibility with old device names on a devfs systems.
@@ -86 +245 @@
       "MKOLDCOMPAT", "MKNEWCOMPAT","RMOLDCOMPAT", "RMNEWCOMPAT".
 
-       But only if they are written UPPERCASE!!!!!!!!
+      But only if they are written UPPERCASE!!!!!!!!
 
 config DEVFSD_MODLOAD
     bool "Adds support for MODLOAD keyword in devsfd.conf"
-    default n
+    default y
     depends on DEVFSD
     help
@@ -98 +257 @@
 config DEVFSD_FG_NP
     bool "Enables the -fg and -np options"
-    default n
+    default y
     depends on DEVFSD
     help
-        -fg Run the daemon in the foreground.
-        -np Exit  after  parsing  the configuration file. Do not poll for events.
+      -fg  Run the daemon in the foreground.
+      -np  Exit after parsing the configuration file.
+           Do not poll for events.
 
 config DEVFSD_VERBOSE
     bool "Increases logging (and size)"
-    default n
+    default y
     depends on DEVFSD
     help
@@ -112 +272 @@
 
 config FEATURE_DEVFS
-    bool "  Use devfs names for all devices (obsolete)"
-    default n
-    help
-      This is obsolete and will be going away at the end of 2008..
-
-      This tells busybox to look for names like /dev/loop/0 instead of
-      /dev/loop0.  If your /dev directory has normal names instead of
+    bool "Use devfs names for all devices (obsolete)"
+    default n
+    depends on PLATFORM_LINUX
+    help
+      This is obsolete and should NOT be used anymore.
+      Use linux >= 2.6 (optionally with hotplug) and mdev instead!
+
+      For legacy systems -- if there is no way around devfsd -- this
+      tells busybox to look for names like /dev/loop/0 instead of
+      /dev/loop0. If your /dev directory has normal names instead of
       devfs names, you don't want this.
+
+config DEVMEM
+    bool "devmem"
+    default y
+    help
+      devmem is a small program that reads and writes from physical
+      memory using /dev/mem.
 
 config EJECT
     bool "eject"
-    default n
-    help
-      Used to eject cdroms.  (defaults to /dev/cdrom)
+    default y
+    depends on PLATFORM_LINUX
+    help
+      Used to eject cdroms. (defaults to /dev/cdrom)
+
+config FEATURE_EJECT_SCSI
+    bool "SCSI support"
+    default y
+    depends on EJECT
+    help
+      Add the -s option to eject, this allows to eject SCSI-Devices and
+      usb-storage devices.
+
+config FBSPLASH
+    bool "fbsplash"
+    default y
+    depends on PLATFORM_LINUX
+    help
+      Shows splash image and progress bar on framebuffer device.
+      Can be used during boot phase of an embedded device. ~2kb.
+      Usage:
+      - use kernel option 'vga=xxx' or otherwise enable fb device.
+      - put somewhere fbsplash.cfg file and an image in .ppm format.
+      - $ setsid fbsplash [params] &
+        -c: hide cursor
+        -d /dev/fbN: framebuffer device (if not /dev/fb0)
+        -s path_to_image_file (can be "-" for stdin)
+        -i path_to_cfg_file (can be "-" for stdin)
+        -f path_to_fifo (can be "-" for stdin)
+      - if you want to run it only in presence of kernel parameter:
+        grep -q "fbsplash=on" </proc/cmdline && setsid fbsplash [params] &
+      - commands for fifo:
+        "NN" (ASCII decimal number) - percentage to show on progress bar
+        "exit" - well you guessed it
+
+config FLASHCP
+    bool "flashcp"
+    default n  # doesn't build on Ubuntu 8.04
+    help
+      The flashcp binary, inspired by mtd-utils as of git head 5eceb74f7.
+      This utility is used to copy images into a MTD device.
+
+config FLASH_LOCK
+    bool "flash_lock"
+    default n  # doesn't build on Ubuntu 8.04
+    help
+      The flash_lock binary from mtd-utils as of git head 5ec0c10d0. This
+      utility locks part or all of the flash device.
+
+config FLASH_UNLOCK
+    bool "flash_unlock"
+    default n  # doesn't build on Ubuntu 8.04
+    help
+      The flash_unlock binary from mtd-utils as of git head 5ec0c10d0. This
+      utility unlocks part or all of the flash device.
+
+config FLASH_ERASEALL
+    bool "flash_eraseall"
+    default n  # doesn't build on Ubuntu 8.04
+    help
+      The flash_eraseall binary from mtd-utils as of git head c4c6a59eb.
+      This utility is used to erase the whole MTD device.
+
+config IONICE
+    bool "ionice"
+    default y
+    depends on PLATFORM_LINUX
+    help
+      Set/set program io scheduling class and priority
+      Requires kernel >= 2.6.13
+
+config INOTIFYD
+    bool "inotifyd"
+    default n  # doesn't build on Knoppix 5
+    help
+      Simple inotify daemon. Reports filesystem changes. Requires
+      kernel >= 2.6.13
 
 config LAST
     bool "last"
-    default n
-    select FEATURE_WTMP
+    default y
+    depends on FEATURE_WTMP
     help
       'last' displays a list of the last users that logged into the system.
+
+choice
+    prompt "Choose last implementation"
+    depends on LAST
+    default FEATURE_LAST_FANCY
+
+config FEATURE_LAST_SMALL
+    bool "small"
+    help
+      This is a small version of last with just the basic set of
+      features.
+
+config FEATURE_LAST_FANCY
+    bool "huge"
+    help
+      'last' displays detailed information about the last users that
+      logged into the system (mimics sysvinit last). +900 bytes.
+endchoice
 
 config LESS
     bool "less"
-    default n
+    default y
     help
       'less' is a pager, meaning that it displays text files. It possesses
@@ -164 +426 @@
       The -m flag enables a simpler status line with a percentage.
 
-config FEATURE_LESS_FLAGCS
-    bool "Enable flag changes"
-    default n
-    depends on LESS
-    help
-      This enables the ability to change command-line flags within
-      less itself.
-
 config FEATURE_LESS_MARKS
     bool "Enable marks"
-    default n
+    default y
     depends on LESS
     help
@@ -181 +435 @@
 config FEATURE_LESS_REGEXP
     bool "Enable regular expressions"
-    default n
+    default y
     depends on LESS
     help
       Enable regular expressions, allowing complex file searches.
+
+config FEATURE_LESS_WINCH
+    bool "Enable automatic resizing on window size changes"
+    default y
+    depends on LESS
+    help
+      Makes less track window size changes.
+
+config FEATURE_LESS_DASHCMD
+    bool "Enable flag changes ('-' command)"
+    default y
+    depends on LESS
+    help
+      This enables the ability to change command-line flags within
+      less itself ('-' keyboard command).
+
+config FEATURE_LESS_LINENUMS
+    bool "Enable dynamic switching of line numbers"
+    default y
+    depends on FEATURE_LESS_DASHCMD
+    help
+      Enables "-N" command.
 
 config HDPARM
     bool "hdparm"
-    default n
-    help
-      Get/Set hard drive parameters.  Primarily intended for ATA
-      drives.  Adds about 13k (or around 30k if you enable the
+    default y
+    depends on PLATFORM_LINUX
+    help
+      Get/Set hard drive parameters. Primarily intended for ATA
+      drives. Adds about 13k (or around 30k if you enable the
       FEATURE_HDPARM_GET_IDENTITY option)....
 
@@ -206 +483 @@
 config FEATURE_HDPARM_HDIO_SCAN_HWIF
     bool "Register an IDE interface (DANGEROUS)"
-    default n
+    default y
     depends on HDPARM
     help
@@ -214 +491 @@
 config FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
     bool "Un-register an IDE interface (DANGEROUS)"
-    default n
+    default y
     depends on HDPARM
     help
@@ -221 +498 @@
 
 config FEATURE_HDPARM_HDIO_DRIVE_RESET
-    bool "perform device reset (DANGEROUS)"
-    default n
+    bool "Perform device reset (DANGEROUS)"
+    default y
     depends on HDPARM
     help
@@ -229 +506 @@
 
 config FEATURE_HDPARM_HDIO_TRISTATE_HWIF
-    bool "tristate device for hotswap (DANGEROUS)"
-    default n
+    bool "Tristate device for hotswap (DANGEROUS)"
+    default y
     depends on HDPARM
     help
       Enables the 'hdparm -x' option to tristate device for hotswap,
-      and the '-b' option to get/set bus state.  This is dangerous
+      and the '-b' option to get/set bus state. This is dangerous
       stuff, so you should probably say N.
 
 config FEATURE_HDPARM_HDIO_GETSET_DMA
-    bool "get/set using_dma flag (DANGEROUS)"
-    default n
+    bool "Get/set using_dma flag"
+    default y
     depends on HDPARM
     help
       Enables the 'hdparm -d' option to get/set using_dma flag.
-      This is dangerous stuff, so you should probably say N.
 
 config MAKEDEVS
     bool "makedevs"
-    default n
+    default y
     help
       'makedevs' is a utility used to create a batch of devices with
       one command.
-      .
+
       There are two choices for command line behaviour, the interface
       as used by LEAF/Linux Router Project, or a device table file.
-      .
+
       'leaf' is traditionally what busybox follows, it allows multiple
       devices of a particluar type to be created per command.
       e.g. /dev/hda[0-9]
       Device properties are passed as command line arguments.
-      .
+
       'table' reads device properties from a file or stdin, allowing
       a batch of unrelated devices to be made with one command.
@@ -277 +553 @@
 endchoice
 
+config MAN
+    bool "man"
+    default y
+    help
+      Format and display manual pages.
+
+config MICROCOM
+    bool "microcom"
+    default y
+    help
+      The poor man's minicom utility for chatting with serial port devices.
+
 config MOUNTPOINT
     bool "mountpoint"
-    default n
+    default y
     help
       mountpoint checks if the directory is a mountpoint.
@@ -285 +573 @@
 config MT
     bool "mt"
-    default n
-    help
-      mt is used to control tape devices.  You can use the mt utility
+    default y
+    help
+      mt is used to control tape devices. You can use the mt utility
       to advance or rewind a tape past a specified number of archive
       files on the tape.
@@ -293 +581 @@
 config RAIDAUTORUN
     bool "raidautorun"
-    default n
+    default y
+    depends on PLATFORM_LINUX
     help
       raidautorun tells the kernel md driver to
@@ -300 +589 @@
 config READAHEAD
     bool "readahead"
-    default n
-    depends on LFS
+    default y
+    depends on LFS && PLATFORM_LINUX
     help
       Preload the files listed on the command line into RAM cache so that
@@ -308 +597 @@
       This applet just calls the readahead(2) system call on each file.
       It is mainly useful in system startup scripts to preload files
-      or executables before they are used.  When used at the right time
-      (in particular when a CPU boundprocess is running) it can
+      or executables before they are used. When used at the right time
+      (in particular when a CPU bound process is running) it can
       significantly speed up system startup.
 
@@ -315 +604 @@
       run this applet as a background job.
 
+config RFKILL
+    bool "rfkill"
+    default n  # doesn't build on Ubuntu 9.04
+    depends on PLATFORM_LINUX
+    help
+      Enable/disable wireless devices.
+
+      rfkill list : list all wireless devices
+      rfkill list bluetooth : list all bluetooth devices
+      rfkill list 1 : list device corresponding to the given index
+      rfkill block|unblock wlan : block/unblock all wlan(wifi) devices
+
 config RUNLEVEL
     bool "runlevel"
-    default n
+    default y
     help
       find the current and previous system runlevel.
@@ -326 +627 @@
 config RX
     bool "rx"
-    default n
+    default y
+    depends on PLATFORM_LINUX
     help
       Receive files using the Xmodem protocol.
+
+config SETSID
+    bool "setsid"
+    default y
+    help
+      setsid runs a program in a new session
 
 config STRINGS
     bool "strings"
-    default n
+    default y
     help
       strings prints the printable character sequences for each file
       specified.
 
-config SETSID
-    bool "setsid"
-    default n
-    help
-      setsid runs a program in a new session
-
 config TASKSET
     bool "taskset"
-    default n
+    default n  # doesn't build on some non-x86 targets (m68k)
     help
       Retrieve or set a processes's CPU affinity.
@@ -351 +653 @@
 
 config FEATURE_TASKSET_FANCY
-    bool "fancy output"
+    bool "Fancy output"
     default y
     depends on TASKSET
@@ -361 +663 @@
 config TIME
     bool "time"
-    default n
+    default y
     help
       The time command runs the specified program with the given arguments.
@@ -367 +669 @@
       giving timing statistics about this program run.
 
+config TIMEOUT
+    bool "timeout"
+    default y
+    help
+      Runs a program and watches it. If it does not terminate in
+      specified number of seconds, it is sent a signal.
+
 config TTYSIZE
     bool "ttysize"
-    default n
+    default y
     help
       A replacement for "stty size". Unlike stty, can report only width,
-      only height, or both, in any order. It also does not complain on error,
-      but returns default 80x24. Usage in shell scripts: width=`ttysize w`.
+      only height, or both, in any order. It also does not complain on
+      error, but returns default 80x24.
+      Usage in shell scripts: width=`ttysize w`.
+
+config VOLNAME
+    bool "volname"
+    default y
+    help
+      Prints a CD-ROM volume name.
+
+config WALL
+    bool "wall"
+    default y
+    help
+      Write a message to all users that are logged in.
 
 config WATCHDOG
     bool "watchdog"
-    default n
+    default y
+    depends on PLATFORM_LINUX
     help
       The watchdog utility is used with hardware or software watchdog
-      device drivers.  It opens the specified watchdog device special file
-      and periodically writes a magic character to the device.  If the
+      device drivers. It opens the specified watchdog device special file
+      and periodically writes a magic character to the device. If the
       watchdog applet ever fails to write the magic character within a
       certain amount of time, the watchdog device assumes the system has
@@ -387 +710 @@
 
 endmenu
-

branches/2.2.9/mindi-busybox/miscutils/Kbuild

@@ +1 @@
+# DO NOT EDIT. This file is generated from Kbuild.src
 # Makefile for busybox
 #
 # Copyright (C) 1999-2005 by Erik Andersen <andersen@codepoet.org>
 #
-# Licensed under the GPL v2, see the file LICENSE in this tarball.
+# Licensed under GPLv2, see file LICENSE in this source tree.
 
 lib-y:=
+
+lib-$(CONFIG_CONSPY) += conspy.o
+lib-$(CONFIG_NANDWRITE) += nandwrite.o
+lib-$(CONFIG_NANDDUMP) += nandwrite.o
+lib-$(CONFIG_UBIATTACH)   += ubi_attach_detach.o
+lib-$(CONFIG_UBIDETACH)   += ubi_attach_detach.o
 lib-$(CONFIG_ADJTIMEX)    += adjtimex.o
 lib-$(CONFIG_BBCONFIG)    += bbconfig.o
+lib-$(CONFIG_BEEP)        += beep.o
+lib-$(CONFIG_CHAT)        += chat.o
 lib-$(CONFIG_CHRT)        += chrt.o
 lib-$(CONFIG_CROND)       += crond.o
@@ -13 +22 @@
 lib-$(CONFIG_DC)          += dc.o
 lib-$(CONFIG_DEVFSD)      += devfsd.o
+lib-$(CONFIG_DEVMEM)      += devmem.o
 lib-$(CONFIG_EJECT)       += eject.o
+lib-$(CONFIG_FBSPLASH)    += fbsplash.o
+lib-$(CONFIG_FLASHCP)     += flashcp.o
+lib-$(CONFIG_FLASH_ERASEALL) += flash_eraseall.o
+lib-$(CONFIG_FLASH_LOCK)     += flash_lock_unlock.o
+lib-$(CONFIG_FLASH_UNLOCK)   += flash_lock_unlock.o
+lib-$(CONFIG_IONICE)      += ionice.o
 lib-$(CONFIG_HDPARM)      += hdparm.o
-lib-$(CONFIG_LAST)        += last.o
+lib-$(CONFIG_INOTIFYD)    += inotifyd.o
+lib-$(CONFIG_FEATURE_LAST_SMALL)+= last.o
+lib-$(CONFIG_FEATURE_LAST_FANCY)+= last_fancy.o
 lib-$(CONFIG_LESS)        += less.o
 lib-$(CONFIG_MAKEDEVS)    += makedevs.o
+lib-$(CONFIG_MAN)         += man.o
+lib-$(CONFIG_MICROCOM)    += microcom.o
 lib-$(CONFIG_MOUNTPOINT)  += mountpoint.o
 lib-$(CONFIG_MT)          += mt.o
 lib-$(CONFIG_RAIDAUTORUN) += raidautorun.o
 lib-$(CONFIG_READAHEAD)   += readahead.o
+lib-$(CONFIG_RFKILL)      += rfkill.o
 lib-$(CONFIG_RUNLEVEL)    += runlevel.o
 lib-$(CONFIG_RX)          += rx.o
@@ -28 +49 @@
 lib-$(CONFIG_TASKSET)     += taskset.o
 lib-$(CONFIG_TIME)        += time.o
+lib-$(CONFIG_TIMEOUT)     += timeout.o
 lib-$(CONFIG_TTYSIZE)     += ttysize.o
+lib-$(CONFIG_VOLNAME)     += volname.o
+lib-$(CONFIG_WALL)        += wall.o
 lib-$(CONFIG_WATCHDOG)    += watchdog.o

branches/2.2.9/mindi-busybox/miscutils/adjtimex.c

@@ -9 +9 @@
  * busyboxed 20 March 2001, Larry Doolittle <ldoolitt@recycle.lbl.gov>
  *
- * Licensed under GPLv2 or later, see file License in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -15 +15 @@
 #include <sys/timex.h>
 
-static const struct {
-    int bit;
-    const char *name;
-} statlist[] = {
-    { STA_PLL,       "PLL"       },
-    { STA_PPSFREQ,   "PPSFREQ"   },
-    { STA_PPSTIME,   "PPSTIME"   },
-    { STA_FLL,       "FFL"       },
-    { STA_INS,       "INS"       },
-    { STA_DEL,       "DEL"       },
-    { STA_UNSYNC,    "UNSYNC"    },
-    { STA_FREQHOLD,  "FREQHOLD"  },
-    { STA_PPSSIGNAL, "PPSSIGNAL" },
-    { STA_PPSJITTER, "PPSJITTER" },
-    { STA_PPSWANDER, "PPSWANDER" },
-    { STA_PPSERROR,  "PPSERROR"  },
-    { STA_CLOCKERR,  "CLOCKERR"  },
-    { 0, NULL }
+static const uint16_t statlist_bit[] = {
+    STA_PLL,
+    STA_PPSFREQ,
+    STA_PPSTIME,
+    STA_FLL,
+    STA_INS,
+    STA_DEL,
+    STA_UNSYNC,
+    STA_FREQHOLD,
+    STA_PPSSIGNAL,
+    STA_PPSJITTER,
+    STA_PPSWANDER,
+    STA_PPSERROR,
+    STA_CLOCKERR,
+    0
 };
+static const char statlist_name[] =
+    "PLL"       "\0"
+    "PPSFREQ"   "\0"
+    "PPSTIME"   "\0"
+    "FFL"       "\0"
+    "INS"       "\0"
+    "DEL"       "\0"
+    "UNSYNC"    "\0"
+    "FREQHOLD"  "\0"
+    "PPSSIGNAL" "\0"
+    "PPSJITTER" "\0"
+    "PPSWANDER" "\0"
+    "PPSERROR"  "\0"
+    "CLOCKERR"
+;
 
-static const char *const ret_code_descript[] = {
-    "clock synchronized",
-    "insert leap second",
-    "delete leap second",
-    "leap second in progress",
-    "leap second has occurred",
+static const char ret_code_descript[] =
+    "clock synchronized" "\0"
+    "insert leap second" "\0"
+    "delete leap second" "\0"
+    "leap second in progress" "\0"
+    "leap second has occurred" "\0"
     "clock not synchronized"
-};
+;
 
-int adjtimex_main(int argc, char **argv);
-int adjtimex_main(int argc, char **argv)
+int adjtimex_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int adjtimex_main(int argc UNUSED_PARAM, char **argv)
 {
     enum {
@@ -53 +65 @@
     char *opt_o, *opt_f, *opt_p, *opt_t;
     struct timex txc;
-    int i, ret, sep;
+    int i, ret;
     const char *descript;
-    txc.modes=0;
 
+    opt_complementary = "=0"; /* no valid non-option parameters */
     opt = getopt32(argv, "qo:f:p:t:",
             &opt_o, &opt_f, &opt_p, &opt_t);
+    txc.modes = 0;
     //if (opt & 0x1) // -q
     if (opt & 0x2) { // -o
@@ -76 +89 @@
         txc.modes |= ADJ_TICK;
     }
-    if (argc != optind) { /* no valid non-option parameters */
-        bb_show_usage();
-    }
 
     ret = adjtimex(&txc);
 
-    if (ret < 0) perror("adjtimex");
+    if (ret < 0) {
+        bb_perror_nomsg_and_die();
+    }
 
-    if (!(opt & OPT_quiet) && ret>=0) {
+    if (!(opt & OPT_quiet)) {
+        int sep;
+        const char *name;
+
         printf(
             "    mode:         %d\n"
@@ -91 +106 @@
             "    maxerror:     %ld\n"
             "    esterror:     %ld\n"
-            "    status:       %d ( ",
+            "    status:       %d (",
         txc.modes, txc.offset, txc.freq, txc.maxerror,
         txc.esterror, txc.status);
@@ -97 +112 @@
         /* representative output of next code fragment:
            "PLL | PPSTIME" */
-        sep=0;
-        for (i=0; statlist[i].name; i++) {
-            if (txc.status & statlist[i].bit) {
-                if (sep) fputs(" | ",stdout);
-                fputs(statlist[i].name,stdout);
-                sep=1;
+        name = statlist_name;
+        sep = 0;
+        for (i = 0; statlist_bit[i]; i++) {
+            if (txc.status & statlist_bit[i]) {
+                if (sep)
+                    fputs(" | ", stdout);
+                fputs(name, stdout);
+                sep = 1;
             }
+            name += strlen(name) + 1;
         }
 
         descript = "error";
-        if (ret >= 0 && ret <= 5) descript = ret_code_descript[ret];
-        printf(" )\n"
+        if (ret <= 5)
+            descript = nth_string(ret_code_descript, ret);
+        printf(")\n"
             "-p  timeconstant: %ld\n"
             "    precision:    %ld\n"
@@ -120 +139 @@
         (long)txc.time.tv_sec, (long)txc.time.tv_usec, ret, descript);
     }
-    return (ret<0);
+
+    return 0;
 }

branches/2.2.9/mindi-busybox/miscutils/bbconfig.c

@@ -4 +4 @@
 #include "libbb.h"
 #include "bbconfigopts.h"
+#if ENABLE_FEATURE_COMPRESS_BBCONFIG
+# include "archive.h"
+# include "bbconfigopts_bz2.h"
+#endif
 
-int bbconfig_main(int argc, char **argv);
-int bbconfig_main(int argc, char **argv)
+int bbconfig_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int bbconfig_main(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
 {
-    printf(bbconfig_config);
+#if ENABLE_FEATURE_COMPRESS_BBCONFIG
+    bunzip_data *bd;
+    int i = start_bunzip(&bd,
+            /* src_fd: */ -1,
+            /* inbuf:  */ bbconfig_config_bz2,
+            /* len:    */ sizeof(bbconfig_config_bz2));
+    /* read_bunzip can longjmp to start_bunzip, and ultimately
+     * end up here with i != 0 on read data errors! Not trivial */
+    if (!i) {
+        /* Cannot use xmalloc: will leak bd in NOFORK case! */
+        char *outbuf = malloc_or_warn(sizeof(bbconfig_config));
+        if (outbuf) {
+            read_bunzip(bd, outbuf, sizeof(bbconfig_config));
+            full_write1_str(outbuf);
+        }
+    }
+#else
+    full_write1_str(bbconfig_config);
+#endif
     return 0;
 }

branches/2.2.9/mindi-busybox/miscutils/chrt.c

@@ -2 +2 @@
 /*
  * chrt - manipulate real-time attributes of a process
- * Copyright (c) 2006-2007 Bernhard Fischer
+ * Copyright (c) 2006-2007 Bernhard Reutner-Fischer
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
-
 #include <sched.h>
-#include <getopt.h> /* optind */
 #include "libbb.h"
 #ifndef _POSIX_PRIORITY_SCHEDULING
 #warning your system may be foobared
 #endif
+
 static const struct {
-    const int policy;
-    const char const name[12];
+    int policy;
+    char name[sizeof("SCHED_OTHER")];
 } policies[] = {
     {SCHED_OTHER, "SCHED_OTHER"},
@@ -22 +21 @@
 };
 
+//TODO: add
+// -b, SCHED_BATCH
+// -i, SCHED_IDLE
+
 static void show_min_max(int pol)
 {
-    const char *fmt = "%s min/max priority\t: %d/%d\n\0%s not supported?\n";
+    const char *fmt = "%s min/max priority\t: %u/%u\n";
     int max, min;
+
     max = sched_get_priority_max(pol);
     min = sched_get_priority_min(pol);
-    if (max >= 0 && min >= 0)
-        printf(fmt, policies[pol].name, min, max);
-    else {
-        fmt += 29;
-        printf(fmt, policies[pol].name);
-    }
+    if ((max|min) < 0)
+        fmt = "%s not supported\n";
+    printf(fmt, policies[pol].name, min, max);
 }
 
@@ -42 +43 @@
 #define OPT_o (1<<4)
 
-int chrt_main(int argc, char** argv);
-int chrt_main(int argc, char** argv)
+int chrt_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int chrt_main(int argc UNUSED_PARAM, char **argv)
 {
     pid_t pid = 0;
     unsigned opt;
     struct sched_param sp;
-    char *p_opt = NULL, *priority = NULL;
-    const char *state = "current\0new";
-    int prio = 0, policy = SCHED_RR;
+    char *pid_str;
+    char *priority = priority; /* for compiler */
+    const char *current_new;
+    int policy = SCHED_RR;
 
-    opt_complementary = "r--fo:f--ro:r--fo"; /* only one policy accepted */
-    opt = getopt32(argv, "+mp:rfo", &p_opt);
+    /* at least 1 arg; only one policy accepted */
+    opt_complementary = "-1:r--fo:f--ro:r--fo";
+    opt = getopt32(argv, "+mprfo");
     if (opt & OPT_r)
         policy = SCHED_RR;
@@ -60 +63 @@
     if (opt & OPT_o)
         policy = SCHED_OTHER;
-
     if (opt & OPT_m) { /* print min/max */
         show_min_max(SCHED_FIFO);
@@ -67 +69 @@
         fflush_stdout_and_exit(EXIT_SUCCESS);
     }
+
+    argv += optind;
     if (opt & OPT_p) {
-        if (argc == optind+1) { /* -p <priority> <pid> */
-            priority = p_opt;
-            p_opt = argv[optind];
+        pid_str = *argv++;
+        if (*argv) { /* "-p <priority> <pid> [...]" */
+            priority = pid_str;
+            pid_str = *argv;
         }
-        argv += optind; /* me -p <arg> */
-        pid = xatoul_range(p_opt, 1, ULONG_MAX); /* -p <pid> */
+        /* else "-p <pid>", and *argv == NULL */
+        pid = xatoul_range(pid_str, 1, ((unsigned)(pid_t)ULONG_MAX) >> 1);
     } else {
-        argv += optind; /* me -p <arg> */
-        priority = *argv;
-    }
-    if (priority) {
-        /* from the manpage of sched_getscheduler:
-           [...] sched_priority can have a value
-           in the range 0 to 99.
-           [...] SCHED_OTHER or SCHED_BATCH  must  be  assigned
-           the  static  priority  0. [...] SCHED_FIFO  or
-           SCHED_RR can have a static priority in the range 1 to 99.
-         */
-        prio = xstrtol_range(priority, 0, policy == SCHED_OTHER
-                                                     ? 0 : 1, 99);
+        priority = *argv++;
+        if (!*argv)
+            bb_show_usage();
     }
 
+    current_new = "current\0new";
     if (opt & OPT_p) {
-        int pol = 0;
-print_rt_info:
+        int pol;
+ print_rt_info:
         pol = sched_getscheduler(pid);
         if (pol < 0)
-            bb_perror_msg_and_die("failed to %cet pid %d's policy", 'g', pid);
+            bb_perror_msg_and_die("can't %cet pid %d's policy", 'g', pid);
         printf("pid %d's %s scheduling policy: %s\n",
-                pid, state, policies[pol].name);
+                pid, current_new, policies[pol].name);
         if (sched_getparam(pid, &sp))
-            bb_perror_msg_and_die("failed to get pid %d's attributes", pid);
+            bb_perror_msg_and_die("can't get pid %d's attributes", pid);
         printf("pid %d's %s scheduling priority: %d\n",
-                pid, state, sp.sched_priority);
-        if (!*argv) /* no new prio given or we did print already, done. */
+                pid, current_new, sp.sched_priority);
+        if (!*argv) {
+            /* Either it was just "-p <pid>",
+             * or it was "-p <priority> <pid>" and we came here
+             * for the second time (see goto below) */
             return EXIT_SUCCESS;
+        }
+        *argv = NULL;
+        current_new += 8;
     }
 
-    sp.sched_priority = prio;
+    /* from the manpage of sched_getscheduler:
+    [...] sched_priority can have a value in the range 0 to 99.
+    [...] SCHED_OTHER or SCHED_BATCH must be assigned static priority 0.
+    [...] SCHED_FIFO or SCHED_RR can have static priority in 1..99 range.
+    */
+    sp.sched_priority = xstrtou_range(priority, 0, policy != SCHED_OTHER ? 1 : 0, 99);
+
     if (sched_setscheduler(pid, policy, &sp) < 0)
-        bb_perror_msg_and_die("failed to %cet pid %d's policy", 's', pid);
-    if (opt & OPT_p) {
-        state += 8;
-        ++argv;
+        bb_perror_msg_and_die("can't %cet pid %d's policy", 's', pid);
+
+    if (!argv[0]) /* "-p <priority> <pid> [...]" */
         goto print_rt_info;
-    }
-    ++argv;
-    BB_EXECVP(*argv, argv);
-    bb_perror_msg_and_die("%s", *argv);
+
+    BB_EXECVP_or_die(argv);
 }
-#undef OPT_p
-#undef OPT_r
-#undef OPT_f
-#undef OPT_o
-#undef OPT_m

branches/2.2.9/mindi-busybox/miscutils/crond.c

@@ -9 +9 @@
  * Vladimir Oleynik <dzo@simtreas.ru> (C) 2002
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
-#include <sys/syslog.h>
 #include "libbb.h"
-
-#ifndef CRONTABS
-#define CRONTABS        "/var/spool/cron/crontabs"
-#endif
-#ifndef TMPDIR
-#define TMPDIR          "/var/spool/cron"
-#endif
+#include <syslog.h>
+
+/* glibc frees previous setenv'ed value when we do next setenv()
+ * of the same variable. uclibc does not do this! */
+#if (defined(__GLIBC__) && !defined(__UCLIBC__)) /* || OTHER_SAFE_LIBC... */
+# define SETENV_LEAKS 0
+#else
+# define SETENV_LEAKS 1
+#endif
+
+
+#define TMPDIR          CONFIG_FEATURE_CROND_DIR
+#define CRONTABS        CONFIG_FEATURE_CROND_DIR "/crontabs"
 #ifndef SENDMAIL
-#define SENDMAIL        "sendmail"
+# define SENDMAIL       "sendmail"
 #endif
 #ifndef SENDMAIL_ARGS
-#define SENDMAIL_ARGS   "-ti", "oem"
+# define SENDMAIL_ARGS  "-ti"
 #endif
 #ifndef CRONUPDATE
-#define CRONUPDATE      "cron.update"
+# define CRONUPDATE     "cron.update"
 #endif
 #ifndef MAXLINES
-#define MAXLINES        256 /* max lines in non-root crontabs */
-#endif
+# define MAXLINES       256  /* max lines in non-root crontabs */
+#endif
+
 
 typedef struct CronFile {
-    struct CronFile *cf_Next;
-    struct CronLine *cf_LineBase;
-    char *cf_User;      /* username                     */
-    int cf_Ready;       /* bool: one or more jobs ready */
-    int cf_Running;     /* bool: one or more jobs running */
-    int cf_Deleted;     /* marked for deletion, ignore  */
+    struct CronFile *cf_next;
+    struct CronLine *cf_lines;
+    char *cf_username;
+    smallint cf_wants_starting;     /* bool: one or more jobs ready */
+    smallint cf_has_running;        /* bool: one or more jobs running */
+    smallint cf_deleted;            /* marked for deletion (but still has running jobs) */
 } CronFile;
 
 typedef struct CronLine {
-    struct CronLine *cl_Next;
-    char *cl_Shell;     /* shell command                        */
-    pid_t cl_Pid;       /* running pid, 0, or armed (-1)        */
-    int cl_MailFlag;    /* running pid is for mail              */
-    int cl_MailPos;     /* 'empty file' size                    */
-    char cl_Mins[60];   /* 0-59                                 */
-    char cl_Hrs[24];    /* 0-23                                 */
-    char cl_Days[32];   /* 1-31                                 */
-    char cl_Mons[12];   /* 0-11                                 */
-    char cl_Dow[7];     /* 0-6, beginning sunday                */
+    struct CronLine *cl_next;
+    char *cl_cmd;                   /* shell command */
+    pid_t cl_pid;                   /* >0:running, <0:needs to be started in this minute, 0:dormant */
+#if ENABLE_FEATURE_CROND_CALL_SENDMAIL
+    int cl_empty_mail_size;         /* size of mail header only, 0 if no mailfile */
+    char *cl_mailto;                /* whom to mail results, may be NULL */
+#endif
+    /* ordered by size, not in natural order. makes code smaller: */
+    char cl_Dow[7];                 /* 0-6, beginning sunday */
+    char cl_Mons[12];               /* 0-11 */
+    char cl_Hrs[24];                /* 0-23 */
+    char cl_Days[32];               /* 1-31 */
+    char cl_Mins[60];               /* 0-59 */
 } CronLine;
 
-#define RUN_RANOUT      1
-#define RUN_RUNNING     2
-#define RUN_FAILED      3
-
-#define DaemonUid 0
-
-#if ENABLE_DEBUG_CROND_OPTION
-static unsigned DebugOpt;
-#endif
-
-static unsigned LogLevel = 8;
-static const char *LogFile;
-static const char *CDir = CRONTABS;
-
-static void startlogger(void);
-
-static void CheckUpdates(void);
-static void SynchronizeDir(void);
-static int TestJobs(time_t t1, time_t t2);
-static void RunJobs(void);
-static int CheckJobs(void);
-
-static void RunJob(const char *user, CronLine * line);
-
-#if ENABLE_FEATURE_CROND_CALL_SENDMAIL
-static void EndJob(const char *user, CronLine * line);
+
+#define DAEMON_UID 0
+
+
+enum {
+    OPT_l = (1 << 0),
+    OPT_L = (1 << 1),
+    OPT_f = (1 << 2),
+    OPT_b = (1 << 3),
+    OPT_S = (1 << 4),
+    OPT_c = (1 << 5),
+    OPT_d = (1 << 6) * ENABLE_FEATURE_CROND_D,
+};
+#if ENABLE_FEATURE_CROND_D
+# define DebugOpt (option_mask32 & OPT_d)
 #else
-#define EndJob(user, line)  line->cl_Pid = 0
-#endif
-
-static void DeleteFile(const char *userName);
-
-static CronFile *FileBase;
-
-
+# define DebugOpt 0
+#endif
+
+
+struct globals {
+    unsigned log_level; /* = 8; */
+    time_t crontab_dir_mtime;
+    const char *log_filename;
+    const char *crontab_dir_name; /* = CRONTABS; */
+    CronFile *cron_files;
+#if SETENV_LEAKS
+    char *env_var_user;
+    char *env_var_home;
+#endif
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define INIT_G() do { \
+    G.log_level = 8; \
+    G.crontab_dir_name = CRONTABS; \
+} while (0)
+
+
+/* 0 is the most verbose, default 8 */
+#define LVL5  "\x05"
+#define LVL7  "\x07"
+#define LVL8  "\x08"
+#define WARN9 "\x49"
+#define DIE9  "\xc9"
+/* level >= 20 is "error" */
+#define ERR20 "\x14"
+
+static void crondlog(const char *ctl, ...) __attribute__ ((format (printf, 1, 2)));
 static void crondlog(const char *ctl, ...)
 {
     va_list va;
-    const char *fmt;
-    int level = (int) (ctl[0] & 0xf);
-    int type = level == 20 ?
-        LOG_ERR : ((ctl[0] & 0100) ? LOG_WARNING : LOG_NOTICE);
-
+    int level = (ctl[0] & 0x1f);
 
     va_start(va, ctl);
-    fmt = ctl + 1;
-    if (level >= LogLevel) {
-
-#if ENABLE_DEBUG_CROND_OPTION
-        if (DebugOpt) {
-            vfprintf(stderr, fmt, va);
-        } else
-#endif
-        if (LogFile == 0) {
-            vsyslog(type, fmt, va);
+    if (level >= (int)G.log_level) {
+        /* Debug mode: all to (non-redirected) stderr, */
+        /* Syslog mode: all to syslog (logmode = LOGMODE_SYSLOG), */
+        if (!DebugOpt && G.log_filename) {
+            /* Otherwise (log to file): we reopen log file at every write: */
+            int logfd = open_or_warn(G.log_filename, O_WRONLY | O_CREAT | O_APPEND);
+            if (logfd >= 0)
+                xmove_fd(logfd, STDERR_FILENO);
+        }
+        /* When we log to syslog, level > 8 is logged at LOG_ERR
+         * syslog level, level <= 8 is logged at LOG_INFO. */
+        if (level > 8) {
+            bb_verror_msg(ctl + 1, va, /* strerr: */ NULL);
         } else {
-#if !ENABLE_DEBUG_CROND_OPTION
-            int logfd = open(LogFile, O_WRONLY | O_CREAT | O_APPEND, 0600);
-#else
-            int logfd = open3_or_warn(LogFile, O_WRONLY | O_CREAT | O_APPEND, 0600);
-#endif
-            if (logfd >= 0) {
-                vdprintf(logfd, fmt, va);
-                close(logfd);
-            }
+            char *msg = NULL;
+            vasprintf(&msg, ctl + 1, va);
+            bb_info_msg("%s: %s", applet_name, msg);
+            free(msg);
         }
     }
     va_end(va);
-    if (ctl[0] & 0200) {
+    if (ctl[0] & 0x80)
         exit(20);
-    }
-}
-
-int crond_main(int ac, char **av);
-int crond_main(int ac, char **av)
-{
-    unsigned opt;
-    char *lopt, *Lopt, *copt;
-    USE_DEBUG_CROND_OPTION(char *dopt;)
-
-    opt_complementary = "f-b:b-f:S-L:L-S" USE_DEBUG_CROND_OPTION(":d-l");
-    opterr = 0;         /* disable getopt 'errors' message. */
-    opt = getopt32(av, "l:L:fbSc:" USE_DEBUG_CROND_OPTION("d:"),
-            &lopt, &Lopt, &copt USE_DEBUG_CROND_OPTION(, &dopt));
-    if (opt & 1) /* -l */
-        LogLevel = xatou(lopt);
-    if (opt & 2) /* -L */
-        if (*Lopt)
-            LogFile = Lopt;
-    if (opt & 32) /* -c */
-        if (*copt)
-            CDir = copt;
-#if ENABLE_DEBUG_CROND_OPTION
-    if (opt & 64) { /* -d */
-        DebugOpt = xatou(dopt);
-        LogLevel = 0;
-    }
-#endif
-
-    /* close stdin and stdout, stderr.
-     * close unused descriptors -  don't need.
-     * optional detach from controlling terminal
-     */
-    if (!(opt & 4))
-        bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, av);
-
-    xchdir(CDir);
-    signal(SIGHUP, SIG_IGN); /* ? original crond dies on HUP... */
-
-    startlogger();  /* need if syslog mode selected */
-
-    /*
-     * main loop - synchronize to 1 second after the minute, minimum sleep
-     *             of 1 second.
-     */
-    crondlog("\011%s " BB_VER " started, log level %d\n",
-             applet_name, LogLevel);
-
-    SynchronizeDir();
-
-    {
-        time_t t1 = time(NULL);
-        time_t t2;
-        long dt;
-        int rescan = 60;
-        short sleep_time = 60;
-
-        write_pidfile("/var/run/crond.pid");
-        for (;;) {
-            sleep((sleep_time + 1) - (short) (time(NULL) % sleep_time));
-
-            t2 = time(NULL);
-            dt = t2 - t1;
-
-            /*
-             * The file 'cron.update' is checked to determine new cron
-             * jobs.  The directory is rescanned once an hour to deal
-             * with any screwups.
-             *
-             * check for disparity.  Disparities over an hour either way
-             * result in resynchronization.  A reverse-indexed disparity
-             * less then an hour causes us to effectively sleep until we
-             * match the original time (i.e. no re-execution of jobs that
-             * have just been run).  A forward-indexed disparity less then
-             * an hour causes intermediate jobs to be run, but only once
-             * in the worst case.
-             *
-             * when running jobs, the inequality used is greater but not
-             * equal to t1, and less then or equal to t2.
-             */
-
-            if (--rescan == 0) {
-                rescan = 60;
-                SynchronizeDir();
-            }
-            CheckUpdates();
-#if ENABLE_DEBUG_CROND_OPTION
-            if (DebugOpt)
-                crondlog("\005Wakeup dt=%d\n", dt);
-#endif
-            if (dt < -60 * 60 || dt > 60 * 60) {
-                t1 = t2;
-                crondlog("\111time disparity of %d minutes detected\n", dt / 60);
-            } else if (dt > 0) {
-                TestJobs(t1, t2);
-                RunJobs();
-                sleep(5);
-                if (CheckJobs() > 0) {
-                    sleep_time = 10;
-                } else {
-                    sleep_time = 60;
-                }
-                t1 = t2;
-            }
-        }
-    }
-    return 0; /* not reached */
-}
-
-static int ChangeUser(const char *user)
-{
-    struct passwd *pas;
-    const char *err_msg;
-
-    /*
-     * Obtain password entry and change privileges
-     */
-    pas = getpwnam(user);
-    if (pas == 0) {
-        crondlog("\011failed to get uid for %s", user);
-        return -1;
-    }
-    setenv("USER", pas->pw_name, 1);
-    setenv("HOME", pas->pw_dir, 1);
-    setenv("SHELL", DEFAULT_SHELL, 1);
-
-    /*
-     * Change running state to the user in question
-     */
-    err_msg = change_identity_e2str(pas);
-    if (err_msg) {
-        crondlog("\011%s for user %s", err_msg, user);
-        return -1;
-    }
-    if (chdir(pas->pw_dir) < 0) {
-        crondlog("\011chdir failed: %s: %m", pas->pw_dir);
-        if (chdir(TMPDIR) < 0) {
-            crondlog("\011chdir failed: %s: %m", TMPDIR);
-            return -1;
-        }
-    }
-    return pas->pw_uid;
-}
-
-static void startlogger(void)
-{
-    if (LogFile == 0) {
-        openlog(applet_name, LOG_CONS | LOG_PID, LOG_CRON);
-    }
-#if ENABLE_DEBUG_CROND_OPTION
-    else {              /* test logfile */
-        int logfd;
-
-        logfd = open3_or_warn(LogFile, O_WRONLY | O_CREAT | O_APPEND, 0600);
-        if (logfd >= 0) {
-            close(logfd);
-        }
-    }
-#endif
-}
-
+}
 
 static const char DowAry[] ALIGN1 =
@@ -298 +154 @@
 ;
 
-static char *ParseField(char *user, char *ary, int modvalue, int off,
+static void ParseField(char *user, char *ary, int modvalue, int off,
                 const char *names, char *ptr)
 /* 'names' is a pointer to a set of 3-char abbreviations */
@@ -306 +162 @@
     int n2 = -1;
 
-    if (base == NULL) {
-        return NULL;
-    }
-
-    while (*ptr != ' ' && *ptr != '\t' && *ptr != '\n') {
+    // this can't happen due to config_read()
+    /*if (base == NULL)
+        return;*/
+
+    while (1) {
         int skip = 0;
 
         /* Handle numeric digit or symbol or '*' */
-
         if (*ptr == '*') {
-            n1 = 0;     /* everything will be filled */
+            n1 = 0;  /* everything will be filled */
             n2 = modvalue - 1;
             skip = 1;
             ++ptr;
-        } else if (*ptr >= '0' && *ptr <= '9') {
+        } else if (isdigit(*ptr)) {
+            char *endp;
             if (n1 < 0) {
-                n1 = strtol(ptr, &ptr, 10) + off;
+                n1 = strtol(ptr, &endp, 10) + off;
             } else {
-                n2 = strtol(ptr, &ptr, 10) + off;
-            }
+                n2 = strtol(ptr, &endp, 10) + off;
+            }
+            ptr = endp; /* gcc likes temp var for &endp */
             skip = 1;
         } else if (names) {
@@ -346 +203 @@
 
         /* handle optional range '-' */
-
         if (skip == 0) {
-            crondlog("\111failed user %s parsing %s\n", user, base);
-            return NULL;
+            goto err;
         }
         if (*ptr == '-' && n2 < 0) {
@@ -360 +215 @@
          * in the character array appropriately.
          */
-
         if (n2 < 0) {
             n2 = n1;
         }
         if (*ptr == '/') {
-            skip = strtol(ptr + 1, &ptr, 10);
-        }
+            char *endp;
+            skip = strtol(ptr + 1, &endp, 10);
+            ptr = endp; /* gcc likes temp var for &endp */
+        }
+
         /*
          * fill array, using a failsafe is the easiest way to prevent
          * an endless loop
          */
-
         {
             int s0 = 1;
@@ -384 +240 @@
                     s0 = skip;
                 }
-            }
-            while (n1 != n2 && --failsafe);
-
-            if (failsafe == 0) {
-                crondlog("\111failed user %s parsing %s\n", user, base);
-                return NULL;
-            }
+                if (--failsafe == 0) {
+                    goto err;
+                }
+            } while (n1 != n2);
         }
         if (*ptr != ',') {
@@ -400 +253 @@
     }
 
-    if (*ptr != ' ' && *ptr != '\t' && *ptr != '\n') {
-        crondlog("\111failed user %s parsing %s\n", user, base);
-        return NULL;
-    }
-
-    while (*ptr == ' ' || *ptr == '\t' || *ptr == '\n') {
-        ++ptr;
-    }
-#if ENABLE_DEBUG_CROND_OPTION
-    if (DebugOpt) {
+    if (*ptr) {
+ err:
+        crondlog(WARN9 "user %s: parse error at %s", user, base);
+        return;
+    }
+
+    if (DebugOpt && (G.log_level <= 5)) { /* like LVL5 */
+        /* can't use crondlog, it inserts '\n' */
         int i;
-
-        for (i = 0; i < modvalue; ++i) {
-            crondlog("\005%d", ary[i]);
-        }
-        crondlog("\005\n");
-    }
-#endif
-
-    return ptr;
-}
-
-static void FixDayDow(CronLine * line)
-{
-    int i;
+        for (i = 0; i < modvalue; ++i)
+            fprintf(stderr, "%d", (unsigned char)ary[i]);
+        bb_putchar_stderr('\n');
+    }
+}
+
+static void FixDayDow(CronLine *line)
+{
+    unsigned i;
     int weekUsed = 0;
     int daysUsed = 0;
 
-    for (i = 0; i < (int)(ARRAY_SIZE(line->cl_Dow)); ++i) {
+    for (i = 0; i < ARRAY_SIZE(line->cl_Dow); ++i) {
         if (line->cl_Dow[i] == 0) {
             weekUsed = 1;
@@ -434 +280 @@
         }
     }
-    for (i = 0; i < (int)(ARRAY_SIZE(line->cl_Days)); ++i) {
+    for (i = 0; i < ARRAY_SIZE(line->cl_Days); ++i) {
         if (line->cl_Days[i] == 0) {
             daysUsed = 1;
@@ -440 +286 @@
         }
     }
-    if (weekUsed && !daysUsed) {
-        memset(line->cl_Days, 0, sizeof(line->cl_Days));
-    }
-    if (daysUsed && !weekUsed) {
-        memset(line->cl_Dow, 0, sizeof(line->cl_Dow));
-    }
-}
-
-
-
-static void SynchronizeFile(const char *fileName)
-{
-    int maxEntries = MAXLINES;
+    if (weekUsed != daysUsed) {
+        if (weekUsed)
+            memset(line->cl_Days, 0, sizeof(line->cl_Days));
+        else /* daysUsed */
+            memset(line->cl_Dow, 0, sizeof(line->cl_Dow));
+    }
+}
+
+/*
+ * delete_cronfile() - delete user database
+ *
+ * Note: multiple entries for same user may exist if we were unable to
+ * completely delete a database due to running processes.
+ */
+//FIXME: we will start a new job even if the old job is running
+//if crontab was reloaded: crond thinks that "new" job is different from "old"
+//even if they are in fact completely the same. Example
+//Crontab was:
+// 0-59 * * * * job1
+// 0-59 * * * * long_running_job2
+//User edits crontab to:
+// 0-59 * * * * job1_updated
+// 0-59 * * * * long_running_job2
+//Bug: crond can now start another long_running_job2 even if old one
+//is still running.
+//OTOH most other versions of cron do not wait for job termination anyway,
+//they end up with multiple copies of jobs if they don't terminate soon enough.
+static void delete_cronfile(const char *userName)
+{
+    CronFile **pfile = &G.cron_files;
+    CronFile *file;
+
+    while ((file = *pfile) != NULL) {
+        if (strcmp(userName, file->cf_username) == 0) {
+            CronLine **pline = &file->cf_lines;
+            CronLine *line;
+
+            file->cf_has_running = 0;
+            file->cf_deleted = 1;
+
+            while ((line = *pline) != NULL) {
+                if (line->cl_pid > 0) {
+                    file->cf_has_running = 1;
+                    pline = &line->cl_next;
+                } else {
+                    *pline = line->cl_next;
+                    free(line->cl_cmd);
+                    free(line);
+                }
+            }
+            if (file->cf_has_running == 0) {
+                *pfile = file->cf_next;
+                free(file->cf_username);
+                free(file);
+                continue;
+            }
+        }
+        pfile = &file->cf_next;
+    }
+}
+
+static void load_crontab(const char *fileName)
+{
+    struct parser_t *parser;
+    struct stat sbuf;
     int maxLines;
-    char buf[1024];
-
-    if (strcmp(fileName, "root") == 0) {
-        maxEntries = 65535;
-    }
-    maxLines = maxEntries * 10;
-
-    if (fileName) {
-        FILE *fi;
-
-        DeleteFile(fileName);
-
-        fi = fopen(fileName, "r");
-        if (fi != NULL) {
-            struct stat sbuf;
-
-            if (fstat(fileno(fi), &sbuf) == 0 && sbuf.st_uid == DaemonUid) {
-                CronFile *file = xzalloc(sizeof(CronFile));
-                CronLine **pline;
-
-                file->cf_User = strdup(fileName);
-                pline = &file->cf_LineBase;
-
-                while (fgets(buf, sizeof(buf), fi) != NULL && --maxLines) {
-                    CronLine line;
-                    char *ptr;
-
-                    trim(buf);
-                    if (buf[0] == 0 || buf[0] == '#') {
-                        continue;
-                    }
-                    if (--maxEntries == 0) {
-                        break;
-                    }
-                    memset(&line, 0, sizeof(line));
-
-#if ENABLE_DEBUG_CROND_OPTION
-                    if (DebugOpt) {
-                        crondlog("\111User %s Entry %s\n", fileName, buf);
-                    }
-#endif
-
-                    /* parse date ranges */
-                    ptr = ParseField(file->cf_User, line.cl_Mins, 60, 0, NULL, buf);
-                    ptr = ParseField(file->cf_User, line.cl_Hrs, 24, 0, NULL, ptr);
-                    ptr = ParseField(file->cf_User, line.cl_Days, 32, 0, NULL, ptr);
-                    ptr = ParseField(file->cf_User, line.cl_Mons, 12, -1, MonAry, ptr);
-                    ptr = ParseField(file->cf_User, line.cl_Dow, 7, 0, DowAry, ptr);
-
-                    /* check failure */
-                    if (ptr == NULL) {
-                        continue;
-                    }
-
-                    /*
-                     * fix days and dow - if one is not * and the other
-                     * is *, the other is set to 0, and vise-versa
-                     */
-
-                    FixDayDow(&line);
-
-                    *pline = xzalloc(sizeof(CronLine));
-                    **pline = line;
-
-                    /* copy command */
-                    (*pline)->cl_Shell = strdup(ptr);
-
-#if ENABLE_DEBUG_CROND_OPTION
-                    if (DebugOpt) {
-                        crondlog("\111    Command %s\n", ptr);
-                    }
-#endif
-
-                    pline = &((*pline)->cl_Next);
-                }
-                *pline = NULL;
-
-                file->cf_Next = FileBase;
-                FileBase = file;
-
-                if (maxLines == 0 || maxEntries == 0) {
-                    crondlog("\111Maximum number of lines reached for user %s\n", fileName);
-                }
-            }
-            fclose(fi);
-        }
-    }
-}
-
-static void CheckUpdates(void)
+    char *tokens[6];
+#if ENABLE_FEATURE_CROND_CALL_SENDMAIL
+    char *mailTo = NULL;
+#endif
+
+    delete_cronfile(fileName);
+
+    if (!getpwnam(fileName)) {
+        crondlog(LVL7 "ignoring file '%s' (no such user)", fileName);
+        return;
+    }
+
+    parser = config_open(fileName);
+    if (!parser)
+        return;
+
+    maxLines = (strcmp(fileName, "root") == 0) ? 65535 : MAXLINES;
+
+    if (fstat(fileno(parser->fp), &sbuf) == 0 && sbuf.st_uid == DAEMON_UID) {
+        CronFile *file = xzalloc(sizeof(CronFile));
+        CronLine **pline;
+        int n;
+
+        file->cf_username = xstrdup(fileName);
+        pline = &file->cf_lines;
+
+        while (1) {
+            CronLine *line;
+
+            if (!--maxLines)
+                break;
+            n = config_read(parser, tokens, 6, 1, "# \t", PARSE_NORMAL | PARSE_KEEP_COPY);
+            if (!n)
+                break;
+
+            if (DebugOpt)
+                crondlog(LVL5 "user:%s entry:%s", fileName, parser->data);
+
+            /* check if line is setting MAILTO= */
+            if (0 == strncmp(tokens[0], "MAILTO=", 7)) {
+#if ENABLE_FEATURE_CROND_CALL_SENDMAIL
+                free(mailTo);
+                mailTo = (tokens[0][7]) ? xstrdup(&tokens[0][7]) : NULL;
+#endif /* otherwise just ignore such lines */
+                continue;
+            }
+            /* check if a minimum of tokens is specified */
+            if (n < 6)
+                continue;
+            *pline = line = xzalloc(sizeof(*line));
+            /* parse date ranges */
+            ParseField(file->cf_username, line->cl_Mins, 60, 0, NULL, tokens[0]);
+            ParseField(file->cf_username, line->cl_Hrs, 24, 0, NULL, tokens[1]);
+            ParseField(file->cf_username, line->cl_Days, 32, 0, NULL, tokens[2]);
+            ParseField(file->cf_username, line->cl_Mons, 12, -1, MonAry, tokens[3]);
+            ParseField(file->cf_username, line->cl_Dow, 7, 0, DowAry, tokens[4]);
+            /*
+             * fix days and dow - if one is not "*" and the other
+             * is "*", the other is set to 0, and vise-versa
+             */
+            FixDayDow(line);
+#if ENABLE_FEATURE_CROND_CALL_SENDMAIL
+            /* copy mailto (can be NULL) */
+            line->cl_mailto = xstrdup(mailTo);
+#endif
+            /* copy command */
+            line->cl_cmd = xstrdup(tokens[5]);
+            if (DebugOpt) {
+                crondlog(LVL5 " command:%s", tokens[5]);
+            }
+            pline = &line->cl_next;
+//bb_error_msg("M[%s]F[%s][%s][%s][%s][%s][%s]", mailTo, tokens[0], tokens[1], tokens[2], tokens[3], tokens[4], tokens[5]);
+        }
+        *pline = NULL;
+
+        file->cf_next = G.cron_files;
+        G.cron_files = file;
+
+        if (maxLines == 0) {
+            crondlog(WARN9 "user %s: too many lines", fileName);
+        }
+    }
+    config_close(parser);
+}
+
+static void process_cron_update_file(void)
 {
     FILE *fi;
     char buf[256];
 
-    fi = fopen(CRONUPDATE, "r");
+    fi = fopen_for_read(CRONUPDATE);
     if (fi != NULL) {
-        remove(CRONUPDATE);
+        unlink(CRONUPDATE);
         while (fgets(buf, sizeof(buf), fi) != NULL) {
-            SynchronizeFile(strtok(buf, " \t\r\n"));
+            /* use first word only */
+            skip_non_whitespace(buf)[0] = '\0';
+            load_crontab(buf);
         }
         fclose(fi);
@@ -558 +454 @@
 }
 
-static void SynchronizeDir(void)
-{
-    /* Attempt to delete the database. */
-
-    for (;;) {
-        CronFile *file;
-
-        for (file = FileBase; file && file->cf_Deleted; file = file->cf_Next);
-        if (file == NULL) {
-            break;
-        }
-        DeleteFile(file->cf_User);
-    }
-
-    /*
-     * Remove cron update file
-     *
-     * Re-chdir, in case directory was renamed & deleted, or otherwise
-     * screwed up.
-     *
-     * scan directory and add associated users
-     */
-
-    remove(CRONUPDATE);
-    if (chdir(CDir) < 0) {
-        crondlog("\311cannot find %s\n", CDir);
-    }
+static void rescan_crontab_dir(void)
+{
+    CronFile *file;
+
+    /* Delete all files until we only have ones with running jobs (or none) */
+ again:
+    for (file = G.cron_files; file; file = file->cf_next) {
+        if (!file->cf_deleted) {
+            delete_cronfile(file->cf_username);
+            goto again;
+        }
+    }
+
+    /* Remove cron update file */
+    unlink(CRONUPDATE);
+    /* Re-chdir, in case directory was renamed & deleted */
+    if (chdir(G.crontab_dir_name) < 0) {
+        crondlog(DIE9 "chdir(%s)", G.crontab_dir_name);
+    }
+
+    /* Scan directory and add associated users */
     {
         DIR *dir = opendir(".");
         struct dirent *den;
 
-        if (dir) {
-            while ((den = readdir(dir))) {
-                if (strchr(den->d_name, '.') != NULL) {
-                    continue;
-                }
-                if (getpwnam(den->d_name)) {
-                    SynchronizeFile(den->d_name);
-                } else {
-                    crondlog("\007ignoring %s\n", den->d_name);
-                }
-            }
-            closedir(dir);
-        } else {
-            crondlog("\311cannot open current dir!\n");
-        }
-    }
-}
-
-
-/*
- *  DeleteFile() - delete user database
- *
- *  Note: multiple entries for same user may exist if we were unable to
- *  completely delete a database due to running processes.
- */
-
-static void DeleteFile(const char *userName)
-{
-    CronFile **pfile = &FileBase;
-    CronFile *file;
-
-    while ((file = *pfile) != NULL) {
-        if (strcmp(userName, file->cf_User) == 0) {
-            CronLine **pline = &file->cf_LineBase;
-            CronLine *line;
-
-            file->cf_Running = 0;
-            file->cf_Deleted = 1;
-
-            while ((line = *pline) != NULL) {
-                if (line->cl_Pid > 0) {
-                    file->cf_Running = 1;
-                    pline = &line->cl_Next;
-                } else {
-                    *pline = line->cl_Next;
-                    free(line->cl_Shell);
-                    free(line);
-                }
-            }
-            if (file->cf_Running == 0) {
-                *pfile = file->cf_Next;
-                free(file->cf_User);
-                free(file);
-            } else {
-                pfile = &file->cf_Next;
-            }
-        } else {
-            pfile = &file->cf_Next;
-        }
-    }
-}
-
-/*
- * TestJobs()
- *
- * determine which jobs need to be run.  Under normal conditions, the
- * period is about a minute (one scan).  Worst case it will be one
- * hour (60 scans).
- */
-
-static int TestJobs(time_t t1, time_t t2)
-{
-    int nJobs = 0;
-    time_t t;
-
-    /* Find jobs > t1 and <= t2 */
-
-    for (t = t1 - t1 % 60; t <= t2; t += 60) {
-        if (t > t1) {
-            struct tm *tp = localtime(&t);
-            CronFile *file;
-            CronLine *line;
-
-            for (file = FileBase; file; file = file->cf_Next) {
-#if ENABLE_DEBUG_CROND_OPTION
-                if (DebugOpt)
-                    crondlog("\005FILE %s:\n", file->cf_User);
-#endif
-                if (file->cf_Deleted)
-                    continue;
-                for (line = file->cf_LineBase; line; line = line->cl_Next) {
-#if ENABLE_DEBUG_CROND_OPTION
-                    if (DebugOpt)
-                        crondlog("\005    LINE %s\n", line->cl_Shell);
-#endif
-                    if (line->cl_Mins[tp->tm_min] && line->cl_Hrs[tp->tm_hour] &&
-                        (line->cl_Days[tp->tm_mday] || line->cl_Dow[tp->tm_wday])
-                        && line->cl_Mons[tp->tm_mon]) {
-#if ENABLE_DEBUG_CROND_OPTION
-                        if (DebugOpt) {
-                            crondlog("\005    JobToDo: %d %s\n",
-                                line->cl_Pid, line->cl_Shell);
-                        }
-#endif
-                        if (line->cl_Pid > 0) {
-                            crondlog("\010    process already running: %s %s\n",
-                                file->cf_User, line->cl_Shell);
-                        } else if (line->cl_Pid == 0) {
-                            line->cl_Pid = -1;
-                            file->cf_Ready = 1;
-                            ++nJobs;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return nJobs;
-}
-
-static void RunJobs(void)
-{
-    CronFile *file;
-    CronLine *line;
-
-    for (file = FileBase; file; file = file->cf_Next) {
-        if (file->cf_Ready) {
-            file->cf_Ready = 0;
-
-            for (line = file->cf_LineBase; line; line = line->cl_Next) {
-                if (line->cl_Pid < 0) {
-
-                    RunJob(file->cf_User, line);
-
-                    crondlog("\010USER %s pid %3d cmd %s\n",
-                        file->cf_User, line->cl_Pid, line->cl_Shell);
-                    if (line->cl_Pid < 0) {
-                        file->cf_Ready = 1;
-                    }
-                    else if (line->cl_Pid > 0) {
-                        file->cf_Running = 1;
-                    }
-                }
-            }
-        }
-    }
-}
-
-/*
- * CheckJobs() - check for job completion
- *
- * Check for job completion, return number of jobs still running after
- * all done.
- */
-
-static int CheckJobs(void)
-{
-    CronFile *file;
-    CronLine *line;
-    int nStillRunning = 0;
-
-    for (file = FileBase; file; file = file->cf_Next) {
-        if (file->cf_Running) {
-            file->cf_Running = 0;
-
-            for (line = file->cf_LineBase; line; line = line->cl_Next) {
-                if (line->cl_Pid > 0) {
-                    int status;
-                    int r = wait4(line->cl_Pid, &status, WNOHANG, NULL);
-
-                    if (r < 0 || r == line->cl_Pid) {
-                        EndJob(file->cf_User, line);
-                        if (line->cl_Pid) {
-                            file->cf_Running = 1;
-                        }
-                    } else if (r == 0) {
-                        file->cf_Running = 1;
-                    }
-                }
-            }
-        }
-        nStillRunning += file->cf_Running;
-    }
-    return nStillRunning;
-}
-
-
+        if (!dir)
+            crondlog(DIE9 "chdir(%s)", "."); /* exits */
+        while ((den = readdir(dir)) != NULL) {
+            if (strchr(den->d_name, '.') != NULL) {
+                continue;
+            }
+            load_crontab(den->d_name);
+        }
+        closedir(dir);
+    }
+}
+
+#if SETENV_LEAKS
+/* We set environment *before* vfork (because we want to use vfork),
+ * so we cannot use setenv() - repeated calls to setenv() may leak memory!
+ * Using putenv(), and freeing memory after unsetenv() won't leak */
+static void safe_setenv(char **pvar_val, const char *var, const char *val)
+{
+    char *var_val = *pvar_val;
+
+    if (var_val) {
+        bb_unsetenv_and_free(var_val);
+    }
+    *pvar_val = xasprintf("%s=%s", var, val);
+    putenv(*pvar_val);
+}
+#endif
+
+static void set_env_vars(struct passwd *pas)
+{
+#if SETENV_LEAKS
+    safe_setenv(&G.env_var_user, "USER", pas->pw_name);
+    safe_setenv(&G.env_var_home, "HOME", pas->pw_dir);
+    /* if we want to set user's shell instead: */
+    /*safe_setenv(G.env_var_shell, "SHELL", pas->pw_shell);*/
+#else
+    xsetenv("USER", pas->pw_name);
+    xsetenv("HOME", pas->pw_dir);
+#endif
+    /* currently, we use constant one: */
+    /*setenv("SHELL", DEFAULT_SHELL, 1); - done earlier */
+}
+
+static void change_user(struct passwd *pas)
+{
+    /* careful: we're after vfork! */
+    change_identity(pas); /* - initgroups, setgid, setuid */
+    if (chdir(pas->pw_dir) < 0) {
+        crondlog(WARN9 "chdir(%s)", pas->pw_dir);
+        if (chdir(TMPDIR) < 0) {
+            crondlog(DIE9 "chdir(%s)", TMPDIR); /* exits */
+        }
+    }
+}
+
+// TODO: sendmail should be _run-time_ option, not compile-time!
 #if ENABLE_FEATURE_CROND_CALL_SENDMAIL
-static void
-ForkJob(const char *user, CronLine * line, int mailFd,
-        const char *prog, const char *cmd, const char *arg, const char *mailf)
-{
-    /* Fork as the user in question and run program */
-    pid_t pid = fork();
-
-    line->cl_Pid = pid;
+
+static pid_t
+fork_job(const char *user, int mailFd,
+        const char *prog,
+        const char *shell_cmd /* if NULL, we run sendmail */
+) {
+    struct passwd *pas;
+    pid_t pid;
+
+    /* prepare things before vfork */
+    pas = getpwnam(user);
+    if (!pas) {
+        crondlog(WARN9 "can't get uid for %s", user);
+        goto err;
+    }
+    set_env_vars(pas);
+
+    pid = vfork();
     if (pid == 0) {
         /* CHILD */
-
-        /* Change running state to the user in question */
-
-        if (ChangeUser(user) < 0) {
-            exit(0);
-        }
-#if ENABLE_DEBUG_CROND_OPTION
+        /* initgroups, setgid, setuid, and chdir to home or TMPDIR */
+        change_user(pas);
         if (DebugOpt) {
-            crondlog("\005Child Running %s\n", prog);
-        }
-#endif
-
+            crondlog(LVL5 "child running %s", prog);
+        }
         if (mailFd >= 0) {
-            dup2(mailFd, mailf != NULL);
-            dup2((mailf ? mailFd : 1), 2);
-            close(mailFd);
-        }
-        execl(prog, prog, cmd, arg, NULL);
-        crondlog("\024cannot exec, user %s cmd %s %s %s\n", user, prog, cmd, arg);
-        if (mailf) {
-            fdprintf(1, "Exec failed: %s -c %s\n", prog, arg);
-        }
-        exit(0);
-    } else if (pid < 0) {
+            xmove_fd(mailFd, shell_cmd ? 1 : 0);
+            dup2(1, 2);
+        }
+        /* crond 3.0pl1-100 puts tasks in separate process groups */
+        bb_setpgrp();
+        execlp(prog, prog, (shell_cmd ? "-c" : SENDMAIL_ARGS), shell_cmd, (char *) NULL);
+        crondlog(ERR20 "can't execute '%s' for user %s", prog, user);
+        if (shell_cmd) {
+            fdprintf(1, "Exec failed: %s -c %s\n", prog, shell_cmd);
+        }
+        _exit(EXIT_SUCCESS);
+    }
+
+    if (pid < 0) {
         /* FORK FAILED */
-        crondlog("\024cannot fork, user %s\n", user);
-        line->cl_Pid = 0;
-        if (mailf) {
-            remove(mailf);
-        }
-    } else if (mailf) {
-        /* PARENT, FORK SUCCESS
-         * rename mail-file based on pid of process
-         */
-        char mailFile2[128];
-
-        snprintf(mailFile2, sizeof(mailFile2), TMPDIR "/cron.%s.%d", user, pid);
-        rename(mailf, mailFile2);
-    }
+        crondlog(ERR20 "can't vfork");
+ err:
+        pid = 0;
+    } /* else: PARENT, FORK SUCCESS */
+
     /*
      * Close the mail file descriptor.. we can't just leave it open in
      * a structure, closing it later, because we might run out of descriptors
      */
-
     if (mailFd >= 0) {
         close(mailFd);
     }
-}
-
-static void RunJob(const char *user, CronLine * line)
+    return pid;
+}
+
+static void start_one_job(const char *user, CronLine *line)
 {
     char mailFile[128];
-    int mailFd;
-
-    line->cl_Pid = 0;
-    line->cl_MailFlag = 0;
-
-    /* open mail file - owner root so nobody can screw with it. */
-
-    snprintf(mailFile, sizeof(mailFile), TMPDIR "/cron.%s.%d", user, getpid());
-    mailFd = open(mailFile, O_CREAT | O_TRUNC | O_WRONLY | O_EXCL | O_APPEND, 0600);
-
+    int mailFd = -1;
+
+    line->cl_pid = 0;
+    line->cl_empty_mail_size = 0;
+
+    if (line->cl_mailto) {
+        /* Open mail file (owner is root so nobody can screw with it) */
+        snprintf(mailFile, sizeof(mailFile), "%s/cron.%s.%d", TMPDIR, user, getpid());
+        mailFd = open(mailFile, O_CREAT | O_TRUNC | O_WRONLY | O_EXCL | O_APPEND, 0600);
+
+        if (mailFd >= 0) {
+            fdprintf(mailFd, "To: %s\nSubject: cron: %s\n\n", line->cl_mailto,
+                line->cl_cmd);
+            line->cl_empty_mail_size = lseek(mailFd, 0, SEEK_CUR);
+        } else {
+            crondlog(ERR20 "can't create mail file %s for user %s, "
+                    "discarding output", mailFile, user);
+        }
+    }
+
+    line->cl_pid = fork_job(user, mailFd, DEFAULT_SHELL, line->cl_cmd);
     if (mailFd >= 0) {
-        line->cl_MailFlag = 1;
-        fdprintf(mailFd, "To: %s\nSubject: cron: %s\n\n", user,
-            line->cl_Shell);
-        line->cl_MailPos = lseek(mailFd, 0, SEEK_CUR);
-    } else {
-        crondlog("\024cannot create mail file user %s file %s, output to /dev/null\n", user, mailFile);
-    }
-
-    ForkJob(user, line, mailFd, DEFAULT_SHELL, "-c", line->cl_Shell, mailFile);
+        if (line->cl_pid <= 0) {
+            unlink(mailFile);
+        } else {
+            /* rename mail-file based on pid of process */
+            char *mailFile2 = xasprintf("%s/cron.%s.%d", TMPDIR, user, (int)line->cl_pid);
+            rename(mailFile, mailFile2); // TODO: xrename?
+            free(mailFile2);
+        }
+    }
 }
 
 /*
- * EndJob - called when job terminates and when mail terminates
+ * process_finished_job - called when job terminates and when mail terminates
  */
-
-static void EndJob(const char *user, CronLine * line)
-{
+static void process_finished_job(const char *user, CronLine *line)
+{
+    pid_t pid;
     int mailFd;
     char mailFile[128];
     struct stat sbuf;
 
-    /* No job */
-
-    if (line->cl_Pid <= 0) {
-        line->cl_Pid = 0;
+    pid = line->cl_pid;
+    line->cl_pid = 0;
+    if (pid <= 0) {
+        /* No job */
         return;
     }
+    if (line->cl_empty_mail_size <= 0) {
+        /* End of job and no mail file, or end of sendmail job */
+        return;
+    }
 
     /*
-     * End of job and no mail file
-     * End of sendmail job
+     * End of primary job - check for mail file.
+     * If size has changed and the file is still valid, we send it.
      */
-
-    snprintf(mailFile, sizeof(mailFile), TMPDIR "/cron.%s.%d", user, line->cl_Pid);
-    line->cl_Pid = 0;
-
-    if (line->cl_MailFlag != 1) {
-        return;
-    }
-    line->cl_MailFlag = 0;
-
-    /*
-     * End of primary job - check for mail file.  If size has increased and
-     * the file is still valid, we sendmail it.
-     */
-
+    snprintf(mailFile, sizeof(mailFile), "%s/cron.%s.%d", TMPDIR, user, (int)pid);
     mailFd = open(mailFile, O_RDONLY);
-    remove(mailFile);
+    unlink(mailFile);
     if (mailFd < 0) {
         return;
     }
 
-    if (fstat(mailFd, &sbuf) < 0 || sbuf.st_uid != DaemonUid
-     || sbuf.st_nlink != 0 || sbuf.st_size == line->cl_MailPos
+    if (fstat(mailFd, &sbuf) < 0
+     || sbuf.st_uid != DAEMON_UID
+     || sbuf.st_nlink != 0
+     || sbuf.st_size == line->cl_empty_mail_size
      || !S_ISREG(sbuf.st_mode)
     ) {
@@ -909 +669 @@
         return;
     }
-    ForkJob(user, line, mailFd, SENDMAIL, SENDMAIL_ARGS, NULL);
-}
-#else
-/* crond without sendmail */
-
-static void RunJob(const char *user, CronLine * line)
-{
+    line->cl_empty_mail_size = 0;
+    /* if (line->cl_mailto) - always true if cl_empty_mail_size was nonzero */
+        line->cl_pid = fork_job(user, mailFd, SENDMAIL, NULL);
+}
+
+#else /* !ENABLE_FEATURE_CROND_CALL_SENDMAIL */
+
+static void start_one_job(const char *user, CronLine *line)
+{
+    struct passwd *pas;
+    pid_t pid;
+
+    pas = getpwnam(user);
+    if (!pas) {
+        crondlog(WARN9 "can't get uid for %s", user);
+        goto err;
+    }
+
+    /* Prepare things before vfork */
+    set_env_vars(pas);
+
     /* Fork as the user in question and run program */
-    pid_t pid = fork();
-
+    pid = vfork();
     if (pid == 0) {
         /* CHILD */
-
-        /* Change running state to the user in question */
-
-        if (ChangeUser(user) < 0) {
-            exit(0);
-        }
-#if ENABLE_DEBUG_CROND_OPTION
+        /* initgroups, setgid, setuid, and chdir to home or TMPDIR */
+        change_user(pas);
         if (DebugOpt) {
-            crondlog("\005Child Running %s\n", DEFAULT_SHELL);
-        }
-#endif
-
-        execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", line->cl_Shell, NULL);
-        crondlog("\024cannot exec, user %s cmd %s -c %s\n", user,
-                 DEFAULT_SHELL, line->cl_Shell);
-        exit(0);
-    } else if (pid < 0) {
+            crondlog(LVL5 "child running %s", DEFAULT_SHELL);
+        }
+        /* crond 3.0pl1-100 puts tasks in separate process groups */
+        bb_setpgrp();
+        execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", line->cl_cmd, (char *) NULL);
+        crondlog(ERR20 "can't execute '%s' for user %s", DEFAULT_SHELL, user);
+        _exit(EXIT_SUCCESS);
+    }
+    if (pid < 0) {
         /* FORK FAILED */
-        crondlog("\024cannot, user %s\n", user);
+        crondlog(ERR20 "can't vfork");
+ err:
         pid = 0;
     }
-    line->cl_Pid = pid;
-}
-#endif /* ENABLE_FEATURE_CROND_CALL_SENDMAIL */
+    line->cl_pid = pid;
+}
+
+#define process_finished_job(user, line)  ((line)->cl_pid = 0)
+
+#endif /* !ENABLE_FEATURE_CROND_CALL_SENDMAIL */
+
+/*
+ * Determine which jobs need to be run.  Under normal conditions, the
+ * period is about a minute (one scan).  Worst case it will be one
+ * hour (60 scans).
+ */
+static void flag_starting_jobs(time_t t1, time_t t2)
+{
+    time_t t;
+
+    /* Find jobs > t1 and <= t2 */
+
+    for (t = t1 - t1 % 60; t <= t2; t += 60) {
+        struct tm *ptm;
+        CronFile *file;
+        CronLine *line;
+
+        if (t <= t1)
+            continue;
+
+        ptm = localtime(&t);
+        for (file = G.cron_files; file; file = file->cf_next) {
+            if (DebugOpt)
+                crondlog(LVL5 "file %s:", file->cf_username);
+            if (file->cf_deleted)
+                continue;
+            for (line = file->cf_lines; line; line = line->cl_next) {
+                if (DebugOpt)
+                    crondlog(LVL5 " line %s", line->cl_cmd);
+                if (line->cl_Mins[ptm->tm_min]
+                 && line->cl_Hrs[ptm->tm_hour]
+                 && (line->cl_Days[ptm->tm_mday] || line->cl_Dow[ptm->tm_wday])
+                 && line->cl_Mons[ptm->tm_mon]
+                ) {
+                    if (DebugOpt) {
+                        crondlog(LVL5 " job: %d %s",
+                            (int)line->cl_pid, line->cl_cmd);
+                    }
+                    if (line->cl_pid > 0) {
+                        crondlog(LVL8 "user %s: process already running: %s",
+                            file->cf_username, line->cl_cmd);
+                    } else if (line->cl_pid == 0) {
+                        line->cl_pid = -1;
+                        file->cf_wants_starting = 1;
+                    }
+                }
+            }
+        }
+    }
+}
+
+static void start_jobs(void)
+{
+    CronFile *file;
+    CronLine *line;
+
+    for (file = G.cron_files; file; file = file->cf_next) {
+        if (!file->cf_wants_starting)
+            continue;
+
+        file->cf_wants_starting = 0;
+        for (line = file->cf_lines; line; line = line->cl_next) {
+            pid_t pid;
+            if (line->cl_pid >= 0)
+                continue;
+
+            start_one_job(file->cf_username, line);
+            pid = line->cl_pid;
+            crondlog(LVL8 "USER %s pid %3d cmd %s",
+                file->cf_username, (int)pid, line->cl_cmd);
+            if (pid < 0) {
+                file->cf_wants_starting = 1;
+            }
+            if (pid > 0) {
+                file->cf_has_running = 1;
+            }
+        }
+    }
+}
+
+/*
+ * Check for job completion, return number of jobs still running after
+ * all done.
+ */
+static int check_completions(void)
+{
+    CronFile *file;
+    CronLine *line;
+    int num_still_running = 0;
+
+    for (file = G.cron_files; file; file = file->cf_next) {
+        if (!file->cf_has_running)
+            continue;
+
+        file->cf_has_running = 0;
+        for (line = file->cf_lines; line; line = line->cl_next) {
+            int r;
+
+            if (line->cl_pid <= 0)
+                continue;
+
+            r = waitpid(line->cl_pid, NULL, WNOHANG);
+            if (r < 0 || r == line->cl_pid) {
+                process_finished_job(file->cf_username, line);
+                if (line->cl_pid == 0) {
+                    /* sendmail was not started for it */
+                    continue;
+                }
+                /* else: sendmail was started, job is still running, fall thru */
+            }
+            /* else: r == 0: "process is still running" */
+            file->cf_has_running = 1;
+        }
+//FIXME: if !file->cf_has_running && file->deleted: delete it!
+//otherwise deleted entries will stay forever, right?
+        num_still_running += file->cf_has_running;
+    }
+    return num_still_running;
+}
+
+int crond_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int crond_main(int argc UNUSED_PARAM, char **argv)
+{
+    time_t t2;
+    int rescan;
+    int sleep_time;
+    unsigned opts;
+
+    INIT_G();
+
+    /* "-b after -f is ignored", and so on for every pair a-b */
+    opt_complementary = "f-b:b-f:S-L:L-S" IF_FEATURE_CROND_D(":d-l")
+            ":l+:d+"; /* -l and -d have numeric param */
+    opts = getopt32(argv, "l:L:fbSc:" IF_FEATURE_CROND_D("d:"),
+            &G.log_level, &G.log_filename, &G.crontab_dir_name
+            IF_FEATURE_CROND_D(,&G.log_level));
+    /* both -d N and -l N set the same variable: G.log_level */
+
+    if (!(opts & OPT_f)) {
+        /* close stdin, stdout, stderr.
+         * close unused descriptors - don't need them. */
+        bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, argv);
+    }
+
+    if (!(opts & OPT_d) && G.log_filename == NULL) {
+        /* logging to syslog */
+        openlog(applet_name, LOG_CONS | LOG_PID, LOG_CRON);
+        logmode = LOGMODE_SYSLOG;
+    }
+
+    xchdir(G.crontab_dir_name);
+    //signal(SIGHUP, SIG_IGN); /* ? original crond dies on HUP... */
+    xsetenv("SHELL", DEFAULT_SHELL); /* once, for all future children */
+    crondlog(LVL8 "crond (busybox "BB_VER") started, log level %d", G.log_level);
+    rescan_crontab_dir();
+    write_pidfile("/var/run/crond.pid");
+
+    /* Main loop */
+    t2 = time(NULL);
+    rescan = 60;
+    sleep_time = 60;
+    for (;;) {
+        struct stat sbuf;
+        time_t t1;
+        long dt;
+
+        t1 = t2;
+
+        /* Synchronize to 1 minute, minimum 1 second */
+        sleep(sleep_time - (time(NULL) % sleep_time) + 1);
+
+        t2 = time(NULL);
+        dt = (long)t2 - (long)t1;
+
+        /*
+         * The file 'cron.update' is checked to determine new cron
+         * jobs.  The directory is rescanned once an hour to deal
+         * with any screwups.
+         *
+         * Check for time jump.  Disparities over an hour either way
+         * result in resynchronization.  A negative disparity
+         * less than an hour causes us to effectively sleep until we
+         * match the original time (i.e. no re-execution of jobs that
+         * have just been run).  A positive disparity less than
+         * an hour causes intermediate jobs to be run, but only once
+         * in the worst case.
+         *
+         * When running jobs, the inequality used is greater but not
+         * equal to t1, and less then or equal to t2.
+         */
+        if (stat(G.crontab_dir_name, &sbuf) != 0)
+            sbuf.st_mtime = 0; /* force update (once) if dir was deleted */
+        if (G.crontab_dir_mtime != sbuf.st_mtime) {
+            G.crontab_dir_mtime = sbuf.st_mtime;
+            rescan = 1;
+        }
+        if (--rescan == 0) {
+            rescan = 60;
+            rescan_crontab_dir();
+        }
+        process_cron_update_file();
+        if (DebugOpt)
+            crondlog(LVL5 "wakeup dt=%ld", dt);
+        if (dt < -60 * 60 || dt > 60 * 60) {
+            crondlog(WARN9 "time disparity of %ld minutes detected", dt / 60);
+            /* and we do not run any jobs in this case */
+        } else if (dt > 0) {
+            /* Usual case: time advances forward, as expected */
+            flag_starting_jobs(t1, t2);
+            start_jobs();
+            if (check_completions() > 0) {
+                /* some jobs are still running */
+                sleep_time = 10;
+            } else {
+                sleep_time = 60;
+            }
+        }
+        /* else: time jumped back, do not run any jobs */
+    } /* for (;;) */
+
+    return 0; /* not reached */
+}

branches/2.2.9/mindi-busybox/miscutils/crontab.c

@@ -8 +8 @@
  * Vladimir Oleynik <dzo@simtreas.ru> (C) 2002
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
 #include "libbb.h"
 
-#ifndef CRONTABS
-#define CRONTABS        "/var/spool/cron/crontabs"
-#endif
-#ifndef TMPDIR
-#define TMPDIR          "/var/spool/cron"
-#endif
+#define CRONTABS        CONFIG_FEATURE_CROND_DIR "/crontabs"
 #ifndef CRONUPDATE
 #define CRONUPDATE      "cron.update"
 #endif
-#ifndef PATH_VI
-#define PATH_VI         "/bin/vi"   /* location of vi */
-#endif
-
-static const char *CDir = CRONTABS;
-
-static void EditFile(const char *user, const char *file);
-static int GetReplaceStream(const char *user, const char *file);
-static int ChangeUser(const char *user, short dochdir);
-
-int crontab_main(int ac, char **av);
-int crontab_main(int ac, char **av)
+
+static void edit_file(const struct passwd *pas, const char *file)
 {
-    enum { NONE, EDIT, LIST, REPLACE, DELETE } option = NONE;
+    const char *ptr;
+    int pid = xvfork();
+
+    if (pid) { /* parent */
+        wait4pid(pid);
+        return;
+    }
+
+    /* CHILD - change user and run editor */
+    /* initgroups, setgid, setuid */
+    change_identity(pas);
+    setup_environment(DEFAULT_SHELL,
+            SETUP_ENV_CHANGEENV | SETUP_ENV_TO_TMP,
+            pas);
+    ptr = getenv("VISUAL");
+    if (!ptr) {
+        ptr = getenv("EDITOR");
+        if (!ptr)
+            ptr = "vi";
+    }
+
+    BB_EXECLP(ptr, ptr, file, NULL);
+    bb_perror_msg_and_die("exec %s", ptr);
+}
+
+static int open_as_user(const struct passwd *pas, const char *file)
+{
+    pid_t pid;
+    char c;
+
+    pid = xvfork();
+    if (pid) { /* PARENT */
+        if (wait4pid(pid) == 0) {
+            /* exitcode 0: child says it can read */
+            return open(file, O_RDONLY);
+        }
+        return -1;
+    }
+
+    /* CHILD */
+    /* initgroups, setgid, setuid */
+    change_identity(pas);
+    /* We just try to read one byte. If it works, file is readable
+     * under this user. We signal that by exiting with 0. */
+    _exit(safe_read(xopen(file, O_RDONLY), &c, 1) < 0);
+}
+
+int crontab_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int crontab_main(int argc UNUSED_PARAM, char **argv)
+{
     const struct passwd *pas;
-    const char *repFile = NULL;
-    int repFd = 0;
-    int i;
-    char caller[256];           /* user that ran program */
-    char buf[1024];
-    int UserId;
-
-    UserId = getuid();
-    pas = getpwuid(UserId);
-    if (pas == NULL)
-        bb_perror_msg_and_die("getpwuid");
-
-    safe_strncpy(caller, pas->pw_name, sizeof(caller));
-
-    i = 1;
-    if (ac > 1) {
-        if (LONE_DASH(av[1])) {
-            option = REPLACE;
-            ++i;
-        } else if (av[1][0] != '-') {
-            option = REPLACE;
-            ++i;
-            repFile = av[1];
-        }
-    }
-
-    for (; i < ac; ++i) {
-        char *ptr = av[i];
-
-        if (*ptr != '-')
+    const char *crontab_dir = CRONTABS;
+    char *tmp_fname;
+    char *new_fname;
+    char *user_name;  /* -u USER */
+    int fd;
+    int src_fd;
+    int opt_ler;
+
+    /* file [opts]     Replace crontab from file
+     * - [opts]        Replace crontab from stdin
+     * -u user         User
+     * -c dir          Crontab directory
+     * -l              List crontab for user
+     * -e              Edit crontab for user
+     * -r              Delete crontab for user
+     * bbox also supports -d == -r, but most other crontab
+     * implementations do not. Deprecated.
+     */
+    enum {
+        OPT_u = (1 << 0),
+        OPT_c = (1 << 1),
+        OPT_l = (1 << 2),
+        OPT_e = (1 << 3),
+        OPT_r = (1 << 4),
+        OPT_ler = OPT_l + OPT_e + OPT_r,
+    };
+
+    opt_complementary = "?1:dr"; /* max one argument; -d implies -r */
+    opt_ler = getopt32(argv, "u:c:lerd", &user_name, &crontab_dir);
+    argv += optind;
+
+    if (sanitize_env_if_suid()) { /* Clears dangerous stuff, sets PATH */
+        /* Run by non-root */
+        if (opt_ler & (OPT_u|OPT_c))
+            bb_error_msg_and_die(bb_msg_you_must_be_root);
+    }
+
+    if (opt_ler & OPT_u) {
+        pas = xgetpwnam(user_name);
+    } else {
+        pas = xgetpwuid(getuid());
+    }
+
+#define user_name DONT_USE_ME_BEYOND_THIS_POINT
+
+    /* From now on, keep only -l, -e, -r bits */
+    opt_ler &= OPT_ler;
+    if ((opt_ler - 1) & opt_ler) /* more than one bit set? */
+        bb_show_usage();
+
+    /* Read replacement file under user's UID/GID/group vector */
+    src_fd = STDIN_FILENO;
+    if (!opt_ler) { /* Replace? */
+        if (!argv[0])
+            bb_show_usage();
+        if (NOT_LONE_DASH(argv[0])) {
+            src_fd = open_as_user(pas, argv[0]);
+            if (src_fd < 0)
+                bb_error_msg_and_die("user %s cannot read %s",
+                        pas->pw_name, argv[0]);
+        }
+    }
+
+    /* cd to our crontab directory */
+    xchdir(crontab_dir);
+
+    tmp_fname = NULL;
+
+    /* Handle requested operation */
+    switch (opt_ler) {
+
+    default: /* case OPT_r: Delete */
+        unlink(pas->pw_name);
+        break;
+
+    case OPT_l: /* List */
+        {
+            char *args[2] = { pas->pw_name, NULL };
+            return bb_cat(args);
+            /* list exits,
+             * the rest go play with cron update file */
+        }
+
+    case OPT_e: /* Edit */
+        tmp_fname = xasprintf("%s.%u", crontab_dir, (unsigned)getpid());
+        /* No O_EXCL: we don't want to be stuck if earlier crontabs
+         * were killed, leaving stale temp file behind */
+        src_fd = xopen3(tmp_fname, O_RDWR|O_CREAT|O_TRUNC, 0600);
+        fchown(src_fd, pas->pw_uid, pas->pw_gid);
+        fd = open(pas->pw_name, O_RDONLY);
+        if (fd >= 0) {
+            bb_copyfd_eof(fd, src_fd);
+            close(fd);
+            xlseek(src_fd, 0, SEEK_SET);
+        }
+        close_on_exec_on(src_fd); /* don't want editor to see this fd */
+        edit_file(pas, tmp_fname);
+        /* fall through */
+
+    case 0: /* Replace (no -l, -e, or -r were given) */
+        new_fname = xasprintf("%s.new", pas->pw_name);
+        fd = open(new_fname, O_WRONLY|O_CREAT|O_TRUNC|O_APPEND, 0600);
+        if (fd >= 0) {
+            bb_copyfd_eof(src_fd, fd);
+            close(fd);
+            xrename(new_fname, pas->pw_name);
+        } else {
+            bb_error_msg("can't create %s/%s",
+                    crontab_dir, new_fname);
+        }
+        if (tmp_fname)
+            unlink(tmp_fname);
+        /*free(tmp_fname);*/
+        /*free(new_fname);*/
+
+    } /* switch */
+
+    /* Bump notification file.  Handle window where crond picks file up
+     * before we can write our entry out.
+     */
+    while ((fd = open(CRONUPDATE, O_WRONLY|O_CREAT|O_APPEND, 0600)) >= 0) {
+        struct stat st;
+
+        fdprintf(fd, "%s\n", pas->pw_name);
+        if (fstat(fd, &st) != 0 || st.st_nlink != 0) {
+            /*close(fd);*/
             break;
-        ptr += 2;
-
-        switch (ptr[-1]) {
-        case 'l':
-            if (ptr[-1] == 'l')
-                option = LIST;
-            /* fall through */
-        case 'e':
-            if (ptr[-1] == 'e')
-                option = EDIT;
-            /* fall through */
-        case 'd':
-            if (ptr[-1] == 'd')
-                option = DELETE;
-            /* fall through */
-        case 'u':
-            if (i + 1 < ac && av[i+1][0] != '-') {
-                ++i;
-                if (getuid() == geteuid()) {
-                    pas = getpwnam(av[i]);
-                    if (pas) {
-                        UserId = pas->pw_uid;
-                    } else {
-                        bb_error_msg_and_die("user %s unknown", av[i]);
-                    }
-                } else {
-                    bb_error_msg_and_die("only the superuser may specify a user");
-                }
-            }
-            break;
-        case 'c':
-            if (getuid() == geteuid()) {
-                CDir = (*ptr) ? ptr : av[++i];
-            } else {
-                bb_error_msg_and_die("-c option: superuser only");
-            }
-            break;
-        default:
-            i = ac;
-            break;
-        }
-    }
-    if (i != ac || option == NONE)
-        bb_show_usage();
-
-    /*
-     * Get password entry
-     */
-
-    pas = getpwuid(UserId);
-    if (pas == NULL)
-        bb_perror_msg_and_die("getpwuid");
-
-    /*
-     * If there is a replacement file, obtain a secure descriptor to it.
-     */
-
-    if (repFile) {
-        repFd = GetReplaceStream(caller, repFile);
-        if (repFd < 0)
-            bb_error_msg_and_die("cannot read replacement file");
-    }
-
-    /*
-     * Change directory to our crontab directory
-     */
-
-    xchdir(CDir);
-
-    /*
-     * Handle options as appropriate
-     */
-
-    switch (option) {
-    case LIST:
-        {
-            FILE *fi;
-
-            fi = fopen(pas->pw_name, "r");
-            if (fi) {
-                while (fgets(buf, sizeof(buf), fi) != NULL)
-                    fputs(buf, stdout);
-                fclose(fi);
-            } else {
-                bb_error_msg("no crontab for %s", pas->pw_name);
-            }
-        }
-        break;
-    case EDIT:
-        {
-/* FIXME: messy code here! we have file copying helpers for this! */
-            FILE *fi;
-            int fd;
-            int n;
-            char tmp[128];
-
-            snprintf(tmp, sizeof(tmp), TMPDIR "/crontab.%d", getpid());
-            fd = xopen3(tmp, O_RDWR|O_CREAT|O_TRUNC|O_EXCL, 0600);
-/* race, use fchown */
-            chown(tmp, getuid(), getgid());
-            fi = fopen(pas->pw_name, "r");
-            if (fi) {
-                while ((n = fread(buf, 1, sizeof(buf), fi)) > 0)
-                    full_write(fd, buf, n);
-            }
-            EditFile(caller, tmp);
-            remove(tmp);
-            lseek(fd, 0L, SEEK_SET);
-            repFd = fd;
-        }
-        option = REPLACE;
-        /* fall through */
-    case REPLACE:
-        {
-/* same here */
-            char path[1024];
-            int fd;
-            int n;
-
-            snprintf(path, sizeof(path), "%s.new", pas->pw_name);
-            fd = open(path, O_CREAT|O_TRUNC|O_APPEND|O_WRONLY, 0600);
-            if (fd >= 0) {
-                while ((n = read(repFd, buf, sizeof(buf))) > 0) {
-                    full_write(fd, buf, n);
-                }
-                close(fd);
-                rename(path, pas->pw_name);
-            } else {
-                bb_error_msg("cannot create %s/%s", CDir, path);
-            }
-            close(repFd);
-        }
-        break;
-    case DELETE:
-        remove(pas->pw_name);
-        break;
-    case NONE:
-    default:
-        break;
-    }
-
-    /*
-     *  Bump notification file.  Handle window where crond picks file up
-     *  before we can write our entry out.
-     */
-
-    if (option == REPLACE || option == DELETE) {
-        FILE *fo;
-        struct stat st;
-
-        while ((fo = fopen(CRONUPDATE, "a"))) {
-            fprintf(fo, "%s\n", pas->pw_name);
-            fflush(fo);
-            if (fstat(fileno(fo), &st) != 0 || st.st_nlink != 0) {
-                fclose(fo);
-                break;
-            }
-            fclose(fo);
-            /* loop */
-        }
-        if (fo == NULL) {
-            bb_error_msg("cannot append to %s/%s", CDir, CRONUPDATE);
-        }
+        }
+        /* st.st_nlink == 0:
+         * file was deleted, maybe crond missed our notification */
+        close(fd);
+        /* loop */
+    }
+    if (fd < 0) {
+        bb_error_msg("can't append to %s/%s",
+                crontab_dir, CRONUPDATE);
     }
     return 0;
 }
-
-static int GetReplaceStream(const char *user, const char *file)
-{
-    int filedes[2];
-    int pid;
-    int fd;
-    int n;
-    char buf[1024];
-
-    if (pipe(filedes) < 0) {
-        perror("pipe");
-        return -1;
-    }
-    pid = fork();
-    if (pid < 0) {
-        perror("fork");
-        return -1;
-    }
-    if (pid > 0) {
-        /*
-         * PARENT
-         */
-
-        close(filedes[1]);
-        if (read(filedes[0], buf, 1) != 1) {
-            close(filedes[0]);
-            filedes[0] = -1;
-        }
-        return filedes[0];
-    }
-
-    /*
-     * CHILD
-     */
-
-    close(filedes[0]);
-
-    if (ChangeUser(user, 0) < 0)
-        exit(0);
-
-    xfunc_error_retval = 0;
-    fd = xopen(file, O_RDONLY);
-    buf[0] = 0;
-    write(filedes[1], buf, 1);
-    while ((n = read(fd, buf, sizeof(buf))) > 0) {
-        write(filedes[1], buf, n);
-    }
-    exit(0);
-}
-
-static void EditFile(const char *user, const char *file)
-{
-    int pid = fork();
-
-    if (pid == 0) {
-        /*
-         * CHILD - change user and run editor
-         */
-        const char *ptr;
-
-        if (ChangeUser(user, 1) < 0)
-            exit(0);
-        ptr = getenv("VISUAL");
-        if (ptr == NULL)
-            ptr = getenv("EDITOR");
-        if (ptr == NULL)
-            ptr = PATH_VI;
-
-        ptr = xasprintf("%s %s", ptr, file);
-        execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", ptr, NULL);
-        bb_perror_msg_and_die("exec");
-    }
-    if (pid < 0) {
-        /*
-         * PARENT - failure
-         */
-        bb_perror_msg_and_die("fork");
-    }
-    wait4(pid, NULL, 0, NULL);
-}
-
-static int ChangeUser(const char *user, short dochdir)
-{
-    struct passwd *pas;
-
-    /*
-     * Obtain password entry and change privileges
-     */
-
-    pas = getpwnam(user);
-    if (pas == NULL) {
-        bb_perror_msg_and_die("failed to get uid for %s", user);
-    }
-    setenv("USER", pas->pw_name, 1);
-    setenv("HOME", pas->pw_dir, 1);
-    setenv("SHELL", DEFAULT_SHELL, 1);
-
-    /*
-     * Change running state to the user in question
-     */
-    change_identity(pas);
-
-    if (dochdir) {
-        if (chdir(pas->pw_dir) < 0) {
-            bb_perror_msg("chdir(%s) by %s failed", pas->pw_dir, user);
-            xchdir(TMPDIR);
-        }
-    }
-    return pas->pw_uid;
-}

branches/2.2.9/mindi-busybox/miscutils/dc.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -7 +7 @@
 #include <math.h>
 
-/* Tiny RPN calculator, because "expr" didn't give me bitwise operations. */
-
-enum { STACK_SIZE = COMMON_BUFSIZE / sizeof(double) };
-
-#define stack ((double*)&bb_common_bufsiz1)
-static unsigned int pointer;
-static unsigned char base;
+//usage:#define dc_trivial_usage
+//usage:       "EXPRESSION..."
+//usage:
+//usage:#define dc_full_usage "\n\n"
+//usage:       "Tiny RPN calculator. Operations:\n"
+//usage:       "+, add, -, sub, *, mul, /, div, %, mod, **, exp, and, or, not, eor,\n"
+//usage:       "p - print top of the stack (without popping),\n"
+//usage:       "f - print entire stack,\n"
+//usage:       "o - pop the value and set output radix (must be 10, 16, 8 or 2).\n"
+//usage:       "Examples: 'dc 2 2 add' -> 4, 'dc 8 8 * 2 2 + /' -> 16"
+//usage:
+//usage:#define dc_example_usage
+//usage:       "$ dc 2 2 + p\n"
+//usage:       "4\n"
+//usage:       "$ dc 8 8 \\* 2 2 + / p\n"
+//usage:       "16\n"
+//usage:       "$ dc 0 1 and p\n"
+//usage:       "0\n"
+//usage:       "$ dc 0 1 or p\n"
+//usage:       "1\n"
+//usage:       "$ echo 72 9 div 8 mul p | dc\n"
+//usage:       "64\n"
+
+#if 0
+typedef unsigned data_t;
+#define DATA_FMT ""
+#elif 0
+typedef unsigned long data_t;
+#define DATA_FMT "l"
+#else
+typedef unsigned long long data_t;
+#define DATA_FMT "ll"
+#endif
+
+
+struct globals {
+    unsigned pointer;
+    unsigned base;
+    double stack[1];
+} FIX_ALIASING;
+enum { STACK_SIZE = (COMMON_BUFSIZE - offsetof(struct globals, stack)) / sizeof(double) };
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define pointer   (G.pointer   )
+#define base      (G.base      )
+#define stack     (G.stack     )
+#define INIT_G() do { \
+    base = 10; \
+} while (0)
+
 
 static void push(double a)
@@ -46 +88 @@
 }
 
+#if ENABLE_FEATURE_DC_LIBM
 static void power(void)
 {
@@ -52 +95 @@
     push(pow(pop(), topower));
 }
+#endif
 
 static void divide(void)
@@ -62 +106 @@
 static void mod(void)
 {
-    unsigned int d = pop();
-
-    push((unsigned int) pop() % d);
+    data_t d = pop();
+
+    push((data_t) pop() % d);
 }
 
 static void and(void)
 {
-    push((unsigned int) pop() & (unsigned int) pop());
+    push((data_t) pop() & (data_t) pop());
 }
 
 static void or(void)
 {
-    push((unsigned int) pop() | (unsigned int) pop());
+    push((data_t) pop() | (data_t) pop());
 }
 
 static void eor(void)
 {
-    push((unsigned int) pop() ^ (unsigned int) pop());
+    push((data_t) pop() ^ (data_t) pop());
 }
 
 static void not(void)
 {
-    push(~(unsigned int) pop());
+    push(~(data_t) pop());
 }
 
 static void set_output_base(void)
 {
-    base = (unsigned char)pop();
-    if ((base != 10) && (base != 16)) {
-        bb_error_msg("error, base %d is not supported", base);
+    static const char bases[] ALIGN1 = { 2, 8, 10, 16, 0 };
+    unsigned b = (unsigned)pop();
+
+    base = *strchrnul(bases, b);
+    if (base == 0) {
+        bb_error_msg("error, base %u is not supported", b);
         base = 10;
     }
@@ -98 +145 @@
 static void print_base(double print)
 {
-    if (base == 16)
-        printf("%x\n", (unsigned int)print);
-    else
-        printf("%g\n", print);
+    data_t x, i;
+
+    x = (data_t) print;
+    if (base == 10) {
+        if (x == print) /* exactly representable as unsigned integer */
+            printf("%"DATA_FMT"u\n", x);
+        else
+            printf("%g\n", print);
+        return;
+    }
+
+    switch (base) {
+    case 16:
+        printf("%"DATA_FMT"x\n", x);
+        break;
+    case 8:
+        printf("%"DATA_FMT"o\n", x);
+        break;
+    default: /* base 2 */
+        i = MAXINT(data_t) - (MAXINT(data_t) >> 1);
+        /* i is 100000...00000 */
+        do {
+            if (x & i)
+                break;
+            i >>= 1;
+        } while (i > 1);
+        do {
+            bb_putchar('1' - !(x & i));
+            i >>= 1;
+        } while (i);
+        bb_putchar('\n');
+    }
 }
 
 static void print_stack_no_pop(void)
 {
-    unsigned int i = pointer;
+    unsigned i = pointer;
     while (i)
         print_base(stack[--i]);
@@ -130 +205 @@
     {"/",   divide},
     {"div", divide},
+#if ENABLE_FEATURE_DC_LIBM
     {"**",  power},
     {"exp", power},
     {"pow", power},
+#endif
     {"%",   mod},
     {"mod", mod},
@@ -143 +220 @@
     {"f", print_stack_no_pop},
     {"o", set_output_base},
-    {"", 0}
+    { "", NULL }
 };
 
 static void stack_machine(const char *argument)
 {
-    char *endPointer = 0;
+    char *endPointer;
     double d;
     const struct op *o = operators;
 
-    if (argument == 0)
-        return;
-
     d = strtod(argument, &endPointer);
 
-    if (endPointer != argument) {
+    if (endPointer != argument && *endPointer == '\0') {
         push(d);
         return;
     }
 
-    while (o->name[0]) {
+    while (o->function) {
         if (strcmp(o->name, argument) == 0) {
             o->function();
@@ -169 +243 @@
         o++;
     }
-    bb_error_msg_and_die("%s: syntax error", argument);
+    bb_error_msg_and_die("syntax error at '%s'", argument);
 }
 
@@ -177 +251 @@
 static char *get_token(char **buffer)
 {
-    char *start = NULL;
-    char *current;
-
-    current = skip_whitespace(*buffer);
-    if (*current != 0) {
-        start = current;
-        current = skip_non_whitespace(current);
-        *buffer = current;
-    }
-    return start;
-}
-
-/* In Perl one might say, scalar m|\s*(\S+)\s*|g */
-static int number_of_tokens(char *buffer)
-{
-    int   i = 0;
-    char *b = buffer;
-    while (get_token(&b)) { i++; }
-    return i;
-}
-
-int dc_main(int argc, char **argv);
-int dc_main(int argc, char **argv)
-{
-    /* take stuff from stdin if no args are given */
-    if (argc <= 1) {
-        int i, len;
-        char *line   = NULL;
-        char *cursor = NULL;
-        char *token  = NULL;
-        while ((line = xmalloc_getline(stdin))) {
+    char *current = skip_whitespace(*buffer);
+    if (*current != '\0') {
+        *buffer = skip_non_whitespace(current);
+        return current;
+    }
+    return NULL;
+}
+
+int dc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int dc_main(int argc UNUSED_PARAM, char **argv)
+{
+    INIT_G();
+
+    argv++;
+    if (!argv[0]) {
+        /* take stuff from stdin if no args are given */
+        char *line;
+        char *cursor;
+        char *token;
+        while ((line = xmalloc_fgetline(stdin)) != NULL) {
             cursor = line;
-            len = number_of_tokens(line);
-            for (i = 0; i < len; i++) {
+            while (1) {
                 token = get_token(&cursor);
-                *cursor++ = 0;
+                if (!token)
+                    break;
+                *cursor++ = '\0';
                 stack_machine(token);
             }
@@ -218 +282 @@
         }
     } else {
-        if (*argv[1] == '-')
-            bb_show_usage();
-        while (argc >= 2) {
-            stack_machine(argv[1]);
-            argv++;
-            argc--;
-        }
+        // why? it breaks "dc -2 2 * p"
+        //if (argv[0][0] == '-')
+        //  bb_show_usage();
+        do {
+            stack_machine(*argv);
+        } while (*++argv);
     }
     return EXIT_SUCCESS;

branches/2.2.9/mindi-busybox/miscutils/devfsd.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -54 +54 @@
       Richard Gooch, c/o ATNF, P. O. Box 76, Epping, N.S.W., 2121, Australia.
 */
-
-//#include <sys/wait.h>
-//#include <sys/ioctl.h>
-//#include <sys/socket.h>
-#include <sys/un.h>
-#include <dirent.h>
-#include <syslog.h>
-#include <sys/sysmacros.h>
 #include "libbb.h"
 #include "xregex.h"
-
+#include <syslog.h>
+
+#include <sys/un.h>
+#include <sys/sysmacros.h>
 
 /* Various defines taken from linux/major.h */
@@ -81 +76 @@
 /* Various defines taken from linux/devfs_fs.h */
 #define DEVFSD_PROTOCOL_REVISION_KERNEL  5
-#define DEVFSD_IOCTL_BASE   'd'
+#define DEVFSD_IOCTL_BASE   'd'
 /*  These are the various ioctls  */
 #define DEVFSDIOC_GET_PROTO_REV         _IOR(DEVFSD_IOCTL_BASE, 0, int)
@@ -98 +93 @@
 /*  Never change this otherwise the binary interface will change   */
 
-struct devfsd_notify_struct
-{   /*  Use native C types to ensure same types in kernel and user space     */
-    unsigned int type;           /*  DEVFSD_NOTIFY_* value                   */
-    unsigned int mode;           /*  Mode of the inode or device entry       */
-    unsigned int major;          /*  Major number of device entry            */
-    unsigned int minor;          /*  Minor number of device entry            */
-    unsigned int uid;            /*  Uid of process, inode or device entry   */
-    unsigned int gid;            /*  Gid of process, inode or device entry   */
-    unsigned int overrun_count;  /*  Number of lost events                   */
-    unsigned int namelen;        /*  Number of characters not including '\0' */
-    /*  The device name MUST come last                                       */
-    char devname[DEVFS_PATHLEN]; /*  This will be '\0' terminated            */
+struct devfsd_notify_struct {
+    /*  Use native C types to ensure same types in kernel and user space     */
+    unsigned int type;           /*  DEVFSD_NOTIFY_* value                   */
+    unsigned int mode;           /*  Mode of the inode or device entry       */
+    unsigned int major;          /*  Major number of device entry            */
+    unsigned int minor;          /*  Minor number of device entry            */
+    unsigned int uid;            /*  Uid of process, inode or device entry   */
+    unsigned int gid;            /*  Gid of process, inode or device entry   */
+    unsigned int overrun_count;  /*  Number of lost events                   */
+    unsigned int namelen;        /*  Number of characters not including '\0' */
+    /*  The device name MUST come last                                       */
+    char devname[DEVFS_PATHLEN]; /*  This will be '\0' terminated            */
 };
 
@@ -157 +152 @@
 #define AC_RESTORE                  11
 
-struct permissions_type
-{
+struct permissions_type {
     mode_t mode;
     uid_t uid;
@@ -164 +158 @@
 };
 
-struct execute_type
-{
+struct execute_type {
     char *argv[MAX_ARGS + 1];  /*  argv[0] must always be the programme  */
 };
 
-struct copy_type
-{
+struct copy_type {
     const char *source;
     const char *destination;
 };
 
-struct action_type
-{
+struct action_type {
     unsigned int what;
     unsigned int when;
 };
 
-struct config_entry_struct
-{
+struct config_entry_struct {
     struct action_type action;
     regex_t preg;
@@ -195 +185 @@
 };
 
-struct get_variable_info
-{
+struct get_variable_info {
     const struct devfsd_notify_struct *info;
     const char *devname;
@@ -289 +278 @@
 #define info_logger(p, fmt, args...)
 #define msg_logger(p, fmt, args...)
-#define msg_logger_and_die(p, fmt, args...)           exit(1)
+#define msg_logger_and_die(p, fmt, args...)           exit(EXIT_FAILURE)
 #define error_logger(p, fmt, args...)
-#define error_logger_and_die(p, fmt, args...)         exit(1)
+#define error_logger_and_die(p, fmt, args...)         exit(EXIT_FAILURE)
 #endif
 
@@ -337 +326 @@
 /*  Public functions follow  */
 
-int devfsd_main(int argc, char **argv);
+int devfsd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int devfsd_main(int argc, char **argv)
 {
@@ -372 +361 @@
 
     fd = xopen(".devfsd", O_RDONLY);
-
-    if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0)
-        bb_perror_msg_and_die("FD_CLOEXEC");
-
+    close_on_exec_on(fd);
     xioctl(fd, DEVFSDIOC_GET_PROTO_REV, &proto_rev);
 
@@ -395 +381 @@
     xioctl(fd, DEVFSDIOC_SET_EVENT_MASK, 0);
 
+    /*  Set up SIGHUP and SIGUSR1 handlers  */
     sigemptyset(&new_action.sa_mask);
     new_action.sa_flags = 0;
-
-    /*  Set up SIGHUP and SIGUSR1 handlers  */
     new_action.sa_handler = signal_handler;
-    if (sigaction(SIGHUP, &new_action, NULL) != 0 || sigaction(SIGUSR1, &new_action, NULL) != 0)
-        bb_error_msg_and_die("sigaction");
-
-    printf("%s v%s  started for %s\n",applet_name, DEVFSD_VERSION, mount_point);
+    sigaction_set(SIGHUP, &new_action);
+    sigaction_set(SIGUSR1, &new_action);
+
+    printf("%s v%s started for %s\n", applet_name, DEVFSD_VERSION, mount_point);
 
     /*  Set umask so that mknod(2), open(2) and mkdir(2) have complete control over permissions  */
@@ -412 +397 @@
 
     if (ENABLE_DEVFSD_FG_NP && no_polling)
-        exit(0);
+        exit(EXIT_SUCCESS);
 
     if (ENABLE_DEVFSD_VERBOSE || ENABLE_DEBUG)
@@ -469 +454 @@
             return;
         }
-        if ((fp = fopen(path, "r")) != NULL) {
+        fp = fopen_for_read(path);
+        if (fp != NULL) {
             while (fgets(buf, STRING_LENGTH, fp) != NULL) {
                 /*  Skip whitespace  */
@@ -564 +550 @@
             new->action.what = AC_PERMISSIONS;
             /*  Get user and group  */
-            if ((ptr = strchr(p[0], '.')) == NULL) {
+            ptr = strchr(p[0], '.');
+            if (ptr == NULL) {
                 msg = "UID.GID";
                 goto process_config_line_err; /*"missing '.' in UID.GID"*/
@@ -651 +638 @@
     while (!caught_signal) {
         errno = 0;
-        bytes = read(fd,(char *) &info, sizeof info);
+        bytes = read(fd, (char *) &info, sizeof info);
         if (caught_signal)
             break;      /*  Must test for this first     */
@@ -749 +736 @@
 
 static void action_modload(const struct devfsd_notify_struct *info,
-                const struct config_entry_struct *entry ATTRIBUTE_UNUSED)
+                const struct config_entry_struct *entry UNUSED_PARAM)
 /*  [SUMMARY] Load a module.
     <info> The devfs change.
@@ -765 +752 @@
     argv[5] = NULL;
 
-    wait4pid(xspawn(argv));
+    spawn_and_wait(argv);
     free(argv[4]);
 }  /*  End Function action_modload  */
@@ -797 +784 @@
     }
     argv[count] = NULL;
-    wait4pid(spawn(argv));
+    spawn_and_wait(argv);
 }   /*  End Function action_execute  */
 
@@ -955 +942 @@
     free(dpath);
     if (S_ISLNK(source_stat.st_mode) || (source_stat.st_mode & S_ISVTX))
-        copy_inode(dpath, &dest_stat,(source_stat.st_mode & ~S_ISVTX) , spath, &source_stat);
+        copy_inode(dpath, &dest_stat, (source_stat.st_mode & ~S_ISVTX), spath, &source_stat);
 
     if (S_ISDIR(source_stat.st_mode))
-        dir_operation(RESTORE, spath, rootlen,NULL);
+        dir_operation(RESTORE, spath, rootlen, NULL);
 }
 
@@ -983 +970 @@
         /*  Same type  */
         if (S_ISLNK(source_stat->st_mode)) {
-            if ((source_len = readlink(sourcepath, source_link, STRING_LENGTH - 1)) < 0
-                || (dest_len   = readlink(destpath  , dest_link  , STRING_LENGTH - 1)) < 0
+            source_len = readlink(sourcepath, source_link, STRING_LENGTH - 1);
+            if ((source_len < 0)
+             || (dest_len = readlink(destpath, dest_link, STRING_LENGTH - 1)) < 0
             )
                 return FALSE;
@@ -1003 +991 @@
     switch (source_stat->st_mode & S_IFMT) {
         case S_IFSOCK:
-            if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
+            fd = socket(AF_UNIX, SOCK_STREAM, 0);
+            if (fd < 0)
                 break;
             un_addr.sun_family = AF_UNIX;
             snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s", destpath);
-            val = bind(fd,(struct sockaddr *) &un_addr,(int) sizeof un_addr);
+            val = bind(fd, (struct sockaddr *) &un_addr, (int) sizeof un_addr);
             close(fd);
             if (val != 0 || chmod(destpath, new_mode & ~S_IFMT) != 0)
@@ -1013 +1002 @@
             goto do_chown;
         case S_IFLNK:
-            if ((val = readlink(sourcepath, symlink_val, STRING_LENGTH - 1)) < 0)
+            val = readlink(sourcepath, symlink_val, STRING_LENGTH - 1);
+            if (val < 0)
                 break;
             symlink_val[val] = '\0';
@@ -1020 +1010 @@
             break;
         case S_IFREG:
-            if ((fd = open(destpath, O_RDONLY | O_CREAT, new_mode & ~S_IFMT)) < 0)
+            fd = open(destpath, O_RDONLY | O_CREAT, new_mode & ~S_IFMT);
+            if (fd < 0)
                 break;
             close(fd);
@@ -1086 +1077 @@
         return atoi(string);
 
-    if (flag == UID && (pw_ent  = getpwnam(string)) != NULL)
+    if (flag == UID && (pw_ent = getpwnam(string)) != NULL)
         return pw_ent->pw_uid;
 
@@ -1095 +1086 @@
 
     if (ENABLE_DEVFSD_VERBOSE)
-        msg_logger(LOG_ERR,"unknown %s: %s, defaulting to %cid=0",  msg, string, msg[0]);
+        msg_logger(LOG_ERR, "unknown %s: %s, defaulting to %cid=0",  msg, string, msg[0]);
     return 0;
 }/*  End Function get_uid_gid  */
@@ -1136 +1127 @@
 {
     static char sbuf[sizeof(int)*3 + 2]; /* sign and NUL */
-
-    char hostname[STRING_LENGTH];
+    static char *hostname;
+
     struct get_variable_info *gv_info = info;
     const char *field_names[] = {
@@ -1146 +1137 @@
     int i;
 
-    if (gethostname(hostname, STRING_LENGTH - 1) != 0)
-        /* Here on error we should do exit(RV_SYS_ERROR), instead we do exit(EXIT_FAILURE) */
-        error_logger_and_die(LOG_ERR, "gethostname");
-
-    hostname[STRING_LENGTH - 1] = '\0';
-
+    if (!hostname)
+        hostname = safe_gethostname();
     /* index_in_str_array returns i>=0  */
     i = index_in_str_array(field_names, variable);
@@ -1201 +1188 @@
     char *path;
 
-    if ((dp = warn_opendir(dir_name)) == NULL)
+    dp = warn_opendir(dir_name);
+    if (dp == NULL)
         return;
 
@@ -1343 +1331 @@
 /* from compat_name.c */
 
-struct translate_struct
-{
+struct translate_struct {
     const char *match;    /*  The string to match to(up to length)                */
     const char *format;   /*  Format of output, "%s" takes data past match string,
@@ -1446 +1433 @@
     /* 2 ==scsi/disc, 4 == scsi/part */
     if (i == 2 || i == 4)
-        compat_name = write_old_sd_name(buffer, major, minor,((i == 2) ? "" : (ptr + 4)));
+        compat_name = write_old_sd_name(buffer, major, minor, ((i == 2) ? "" : (ptr + 4)));
 
     /* 5 == scsi/mt */
@@ -1585 +1572 @@
                 if (isspace(ch) ||(ch == '/') ||(ch == '\0')) {
                     /* User's own home directory: leave separator for next time */
-                    if ((env = getenv("HOME")) == NULL) {
+                    env = getenv("HOME");
+                    if (env == NULL) {
                         info_logger(LOG_INFO, bb_msg_variable_not_found, "HOME");
                         return FALSE;
@@ -1604 +1592 @@
                 safe_memcpy(tmp, input, len);
                 input = ptr - 1;
-                if ((pwent = getpwnam(tmp)) == NULL) {
+                pwent = getpwnam(tmp);
+                if (pwent == NULL) {
                     info_logger(LOG_INFO, "no pwent for: %s", tmp);
                     return FALSE;
@@ -1664 +1653 @@
     if (ch == '$') {
         /*  Special case for "$$": PID  */
-        sprintf(tmp, "%d",(int) getpid());
+        sprintf(tmp, "%d", (int) getpid());
         len = strlen(tmp);
         if (len + *out_pos >= length)
@@ -1684 +1673 @@
         safe_memcpy(tmp, input, len);
         input = ptr - 1;
-        if ((env = get_variable_v2(tmp, func, info)) == NULL) {
+        env = get_variable_v2(tmp, func, info);
+        if (env == NULL) {
             info_logger(LOG_INFO, bb_msg_variable_not_found, tmp);
             return NULL;
@@ -1736 +1726 @@
                 break;
             case '\0':
-                info_logger(LOG_INFO,"\"}\" not found in: %s", input);
+                info_logger(LOG_INFO, "\"}\" not found in: %s", input);
                 return NULL;
             default:
@@ -1744 +1734 @@
     --ptr;
     /*  At this point ptr should point to closing brace of "${var:-word}"  */
-    if ((env = get_variable_v2(tmp, func, info)) != NULL) {
+    env = get_variable_v2(tmp, func, info);
+    if (env != NULL) {
         /*  Found environment variable, so skip the input to the closing brace
             and return the variable  */

branches/2.2.9/mindi-busybox/miscutils/eject.c

@@ -6 +6 @@
  * Copyright (C) 2005  Tito Ragusa <farmatito@tiscali.it>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -14 +14 @@
  */
 
+#include <sys/mount.h>
 #include "libbb.h"
+/* Must be after libbb.h: they need size_t */
+#include "fix_u32.h"
+#include <scsi/sg.h>
+#include <scsi/scsi.h>
 
 /* various defines swiped from linux/cdrom.h */
@@ -23 +28 @@
 #define CDS_TRAY_OPEN        2
 
+#define dev_fd 3
+
+/* Code taken from the original eject (http://eject.sourceforge.net/),
+ * refactored it a bit for busybox (ne-bb@nicoerfurth.de) */
+
+static void eject_scsi(const char *dev)
+{
+    static const char sg_commands[3][6] = {
+        { ALLOW_MEDIUM_REMOVAL, 0, 0, 0, 0, 0 },
+        { START_STOP, 0, 0, 0, 1, 0 },
+        { START_STOP, 0, 0, 0, 2, 0 }
+    };
+
+    unsigned i;
+    unsigned char sense_buffer[32];
+    unsigned char inqBuff[2];
+    sg_io_hdr_t io_hdr;
+
+    if ((ioctl(dev_fd, SG_GET_VERSION_NUM, &i) < 0) || (i < 30000))
+        bb_error_msg_and_die("not a sg device or old sg driver");
+
+    memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
+    io_hdr.interface_id = 'S';
+    io_hdr.cmd_len = 6;
+    io_hdr.mx_sb_len = sizeof(sense_buffer);
+    io_hdr.dxfer_direction = SG_DXFER_NONE;
+    /* io_hdr.dxfer_len = 0; */
+    io_hdr.dxferp = inqBuff;
+    io_hdr.sbp = sense_buffer;
+    io_hdr.timeout = 2000;
+
+    for (i = 0; i < 3; i++) {
+        io_hdr.cmdp = (void *)sg_commands[i];
+        ioctl_or_perror_and_die(dev_fd, SG_IO, (void *)&io_hdr, "%s", dev);
+    }
+
+    /* force kernel to reread partition table when new disc is inserted */
+    ioctl(dev_fd, BLKRRPART);
+}
+
 #define FLAG_CLOSE  1
 #define FLAG_SMART  2
+#define FLAG_SCSI   4
 
-int eject_main(int argc, char **argv);
-int eject_main(int argc, char **argv)
+static void eject_cdrom(unsigned flags, const char *dev)
 {
-    unsigned long flags;
+    int cmd = CDROMEJECT;
+
+    if (flags & FLAG_CLOSE
+     || ((flags & FLAG_SMART) && ioctl(dev_fd, CDROM_DRIVE_STATUS) == CDS_TRAY_OPEN)
+    ) {
+        cmd = CDROMCLOSETRAY;
+    }
+
+    ioctl_or_perror_and_die(dev_fd, cmd, NULL, "%s", dev);
+}
+
+int eject_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int eject_main(int argc UNUSED_PARAM, char **argv)
+{
+    unsigned flags;
     const char *device;
-    int dev, cmd;
 
     opt_complementary = "?1:t--T:T--t";
-    flags = getopt32(argv, "tT");
-    device = argv[optind] ? : "/dev/cdrom";
+    flags = getopt32(argv, "tT" IF_FEATURE_EJECT_SCSI("s"));
+    device = argv[optind] ? argv[optind] : "/dev/cdrom";
 
-    // We used to do "umount <device>" here, but it was buggy
-    // if something was mounted OVER cdrom and
-    // if cdrom is mounted many times.
-    //
-    // This works equally well (or better):
-    // #!/bin/sh
-    // umount /dev/cdrom
-    // eject
+    /* We used to do "umount <device>" here, but it was buggy
+       if something was mounted OVER cdrom and
+       if cdrom is mounted many times.
 
-    dev = xopen(device, O_RDONLY|O_NONBLOCK);
-    cmd = CDROMEJECT;
-    if (flags & FLAG_CLOSE
-     || (flags & FLAG_SMART && ioctl(dev, CDROM_DRIVE_STATUS) == CDS_TRAY_OPEN))
-        cmd = CDROMCLOSETRAY;
+       This works equally well (or better):
+       #!/bin/sh
+       umount /dev/cdrom
+       eject /dev/cdrom
+    */
 
-    ioctl_or_perror_and_die(dev, cmd, NULL, "%s", device);
+    xmove_fd(xopen_nonblocking(device), dev_fd);
+
+    if (ENABLE_FEATURE_EJECT_SCSI && (flags & FLAG_SCSI))
+        eject_scsi(device);
+    else
+        eject_cdrom(flags, device);
 
     if (ENABLE_FEATURE_CLEAN_UP)
-        close(dev);
+        close(dev_fd);
 
     return EXIT_SUCCESS;

branches/2.2.9/mindi-busybox/miscutils/hdparm.c

@@ -6 +6 @@
  * Hacked by Tito <farmatito@tiscali.it> for size optimization.
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
  * This program is based on the source code of hdparm: see below...
@@ -12 +12 @@
  *          - by Mark Lord (C) 1994-2002 -- freely distributable
  */
-
 #include "libbb.h"
+/* must be _after_ libbb.h: */
 #include <linux/hdreg.h>
+#include <sys/mount.h>
+#if !defined(BLKGETSIZE64)
+# define BLKGETSIZE64 _IOR(0x12,114,size_t)
+#endif
 
 /* device types */
@@ -60 +64 @@
                     /* multiword DMA xfer cycle time: */
 #define DMA_TIME_MIN        65  /*   - minimum */
-#define DMA_TIME_NORM       66  /*   - manufacturer's recommended   */
+#define DMA_TIME_NORM       66  /*   - manufacturer's recommended */
                     /* minimum PIO xfer cycle time: */
 #define PIO_NO_FLOW     67  /*   - without flow control */
@@ -83 +87 @@
 #define ADV_PWR         91  /* current advanced power management level
                        in low byte, 0x40 in high byte. */
-#define PSWD_CODE       92  /* master password revision code    */
+#define PSWD_CODE       92  /* master password revision code */
 #define HWRST_RSLT      93  /* hardware reset result */
 #define ACOUSTIC        94  /* acoustic mgmt values ( >= ATA-6) */
@@ -128 +132 @@
 #define CDROM 0x0005
 
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const pkt_str[] = {
-    "Direct-access device",         /* word 0, bits 12-8 = 00 */
-    "Sequential-access device",     /* word 0, bits 12-8 = 01 */
-    "Printer",              /* word 0, bits 12-8 = 02 */
-    "Processor",                /* word 0, bits 12-8 = 03 */
-    "Write-once device",            /* word 0, bits 12-8 = 04 */
-    "CD-ROM",               /* word 0, bits 12-8 = 05 */
-    "Scanner",              /* word 0, bits 12-8 = 06 */
-    "Optical memory",           /* word 0, bits 12-8 = 07 */
-    "Medium changer",           /* word 0, bits 12-8 = 08 */
-    "Communications device",        /* word 0, bits 12-8 = 09 */
-    "ACS-IT8 device",           /* word 0, bits 12-8 = 0a */
-    "ACS-IT8 device",           /* word 0, bits 12-8 = 0b */
-    "Array controller",         /* word 0, bits 12-8 = 0c */
-    "Enclosure services",           /* word 0, bits 12-8 = 0d */
-    "Reduced block command device",     /* word 0, bits 12-8 = 0e */
-    "Optical card reader/writer",       /* word 0, bits 12-8 = 0f */
-    "",                 /* word 0, bits 12-8 = 10 */
-    "",                 /* word 0, bits 12-8 = 11 */
-    "",                 /* word 0, bits 12-8 = 12 */
-    "",                 /* word 0, bits 12-8 = 13 */
-    "",                 /* word 0, bits 12-8 = 14 */
-    "",                 /* word 0, bits 12-8 = 15 */
-    "",                 /* word 0, bits 12-8 = 16 */
-    "",                 /* word 0, bits 12-8 = 17 */
-    "",                 /* word 0, bits 12-8 = 18 */
-    "",                 /* word 0, bits 12-8 = 19 */
-    "",                 /* word 0, bits 12-8 = 1a */
-    "",                 /* word 0, bits 12-8 = 1b */
-    "",                 /* word 0, bits 12-8 = 1c */
-    "",                 /* word 0, bits 12-8 = 1d */
-    "",                 /* word 0, bits 12-8 = 1e */
-    "Unknown",          /* word 0, bits 12-8 = 1f */
-};
-
-static const char *const ata1_cfg_str[] = {         /* word 0 in ATA-1 mode */
-    "Reserved",             /* bit 0 */
-    "hard sectored",            /* bit 1 */
-    "soft sectored",            /* bit 2 */
-    "not MFM encoded ",         /* bit 3 */
-    "head switch time > 15us",      /* bit 4 */
-    "spindle motor control option",     /* bit 5 */
-    "fixed drive",              /* bit 6 */
-    "removable drive",          /* bit 7 */
-    "disk xfer rate <= 5Mbs",       /* bit 8 */
-    "disk xfer rate > 5Mbs, <= 10Mbs",  /* bit 9 */
-    "disk xfer rate > 5Mbs",        /* bit 10 */
-    "rotational speed tol.",        /* bit 11 */
-    "data strobe offset option",        /* bit 12 */
-    "track offset option",          /* bit 13 */
-    "format speed tolerance gap reqd",  /* bit 14 */
-    "ATAPI"                 /* bit 14 */
-};
-#endif
-
 /* word 1: number of logical cylinders */
 #define LCYLS_MAX       0x3fff /* maximum allowable value */
@@ -239 +187 @@
 /* word 81: minor version number */
 #define MINOR_MAX       0x22
+/* words 82-84: cmds/feats supported */
+#define CMDS_W82        0x77ff  /* word 82: defined command locations*/
+#define CMDS_W83        0x3fff  /* word 83: defined command locations*/
+#define CMDS_W84        0x002f  /* word 83: defined command locations*/
+#define SUPPORT_48_BIT      0x0400
+#define NUM_CMD_FEAT_STR    48
+
+/* words 85-87: cmds/feats enabled */
+/* use cmd_feat_str[] to display what commands and features have
+ * been enabled with words 85-87
+ */
+
+/* words 89, 90, SECU ERASE TIME */
+#define ERASE_BITS      0x00ff
+
+/* word 92: master password revision */
+/* NOVAL_0 or  NOVAL_1 means no support for master password revision */
+
+/* word 93: hw reset result */
+#define CBLID           0x2000  /* CBLID status */
+#define RST0            0x0001  /* 1=reset to device #0 */
+#define DEV_DET         0x0006  /* how device num determined */
+#define JUMPER_VAL      0x0002  /* device num determined by jumper */
+#define CSEL_VAL        0x0004  /* device num determined by CSEL_VAL */
+
+/* word 127: removable media status notification feature set support */
+#define RM_STAT_BITS    0x0003
+#define RM_STAT_SUP     0x0001
+
+/* word 128: security */
+#define SECU_ENABLED    0x0002
+#define SECU_LEVEL      0x0010
+#define NUM_SECU_STR    6
+
+/* word 160: CFA power mode */
+#define VALID_W160              0x8000  /* 1=word valid */
+#define PWR_MODE_REQ            0x2000  /* 1=CFA power mode req'd by some cmds*/
+#define PWR_MODE_OFF            0x1000  /* 1=CFA power moded disabled */
+#define MAX_AMPS                0x0fff  /* value = max current in ma */
+
+/* word 255: integrity */
+#define SIG                     0x00ff  /* signature location */
+#define SIG_VAL                 0x00a5  /* signature value */
+
+#define TIMING_BUF_MB           1
+#define TIMING_BUF_BYTES        (TIMING_BUF_MB * 1024 * 1024)
+
+#undef DO_FLUSHCACHE            /* under construction: force cache flush on -W0 */
+
+
+#define IS_GET 1
+#define IS_SET 2
+
+
+enum { fd = 3 };
+
+
+struct globals {
+    smallint get_identity, get_geom;
+    smallint do_flush;
+    smallint do_ctimings, do_timings;
+    smallint reread_partn;
+    smallint set_piomode, noisy_piomode;
+    smallint getset_readahead;
+    smallint getset_readonly;
+    smallint getset_unmask;
+    smallint getset_mult;
+#ifdef HDIO_GET_QDMA
+    smallint getset_dma_q;
+#endif
+    smallint getset_nowerr;
+    smallint getset_keep;
+    smallint getset_io32bit;
+    int piomode;
+    unsigned long Xreadahead;
+    unsigned long readonly;
+    unsigned long unmask;
+    unsigned long mult;
+#ifdef HDIO_SET_QDMA
+    unsigned long dma_q;
+#endif
+    unsigned long nowerr;
+    unsigned long keep;
+    unsigned long io32bit;
+#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
+    unsigned long dma;
+    smallint getset_dma;
+#endif
+#ifdef HDIO_DRIVE_CMD
+    smallint set_xfermode, get_xfermode;
+    smallint getset_dkeep;
+    smallint getset_standby;
+    smallint getset_lookahead;
+    smallint getset_prefetch;
+    smallint getset_defects;
+    smallint getset_wcache;
+    smallint getset_doorlock;
+    smallint set_seagate;
+    smallint set_standbynow;
+    smallint set_sleepnow;
+    smallint get_powermode;
+    smallint getset_apmmode;
+    int xfermode_requested;
+    unsigned long dkeep;
+    unsigned long standby_requested; /* 0..255 */
+    unsigned long lookahead;
+    unsigned long prefetch;
+    unsigned long defects;
+    unsigned long wcache;
+    unsigned long doorlock;
+    unsigned long apmmode;
+#endif
+    IF_FEATURE_HDPARM_GET_IDENTITY(        smallint get_IDentity;)
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  smallint getset_busstate;)
+    IF_FEATURE_HDPARM_HDIO_DRIVE_RESET(    smallint perform_reset;)
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  smallint perform_tristate;)
+    IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(smallint unregister_hwif;)
+    IF_FEATURE_HDPARM_HDIO_SCAN_HWIF(      smallint scan_hwif;)
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  unsigned long busstate;)
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  unsigned long tristate;)
+    IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(unsigned long hwif;)
+#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
+    unsigned long hwif_data;
+    unsigned long hwif_ctrl;
+    unsigned long hwif_irq;
+#endif
+#ifdef DO_FLUSHCACHE
+    unsigned char flushcache[4] = { WIN_FLUSHCACHE, 0, 0, 0 };
+#endif
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+struct BUG_G_too_big {
+    char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
+};
+#define get_identity       (G.get_identity           )
+#define get_geom           (G.get_geom               )
+#define do_flush           (G.do_flush               )
+#define do_ctimings        (G.do_ctimings            )
+#define do_timings         (G.do_timings             )
+#define reread_partn       (G.reread_partn           )
+#define set_piomode        (G.set_piomode            )
+#define noisy_piomode      (G.noisy_piomode          )
+#define getset_readahead   (G.getset_readahead       )
+#define getset_readonly    (G.getset_readonly        )
+#define getset_unmask      (G.getset_unmask          )
+#define getset_mult        (G.getset_mult            )
+#define getset_dma_q       (G.getset_dma_q           )
+#define getset_nowerr      (G.getset_nowerr          )
+#define getset_keep        (G.getset_keep            )
+#define getset_io32bit     (G.getset_io32bit         )
+#define piomode            (G.piomode                )
+#define Xreadahead         (G.Xreadahead             )
+#define readonly           (G.readonly               )
+#define unmask             (G.unmask                 )
+#define mult               (G.mult                   )
+#define dma_q              (G.dma_q                  )
+#define nowerr             (G.nowerr                 )
+#define keep               (G.keep                   )
+#define io32bit            (G.io32bit                )
+#define dma                (G.dma                    )
+#define getset_dma         (G.getset_dma             )
+#define set_xfermode       (G.set_xfermode           )
+#define get_xfermode       (G.get_xfermode           )
+#define getset_dkeep       (G.getset_dkeep           )
+#define getset_standby     (G.getset_standby         )
+#define getset_lookahead   (G.getset_lookahead       )
+#define getset_prefetch    (G.getset_prefetch        )
+#define getset_defects     (G.getset_defects         )
+#define getset_wcache      (G.getset_wcache          )
+#define getset_doorlock    (G.getset_doorlock        )
+#define set_seagate        (G.set_seagate            )
+#define set_standbynow     (G.set_standbynow         )
+#define set_sleepnow       (G.set_sleepnow           )
+#define get_powermode      (G.get_powermode          )
+#define getset_apmmode     (G.getset_apmmode         )
+#define xfermode_requested (G.xfermode_requested     )
+#define dkeep              (G.dkeep                  )
+#define standby_requested  (G.standby_requested      )
+#define lookahead          (G.lookahead              )
+#define prefetch           (G.prefetch               )
+#define defects            (G.defects                )
+#define wcache             (G.wcache                 )
+#define doorlock           (G.doorlock               )
+#define apmmode            (G.apmmode                )
+#define get_IDentity       (G.get_IDentity           )
+#define getset_busstate    (G.getset_busstate        )
+#define perform_reset      (G.perform_reset          )
+#define perform_tristate   (G.perform_tristate       )
+#define unregister_hwif    (G.unregister_hwif        )
+#define scan_hwif          (G.scan_hwif              )
+#define busstate           (G.busstate               )
+#define tristate           (G.tristate               )
+#define hwif               (G.hwif                   )
+#define hwif_data          (G.hwif_data              )
+#define hwif_ctrl          (G.hwif_ctrl              )
+#define hwif_irq           (G.hwif_irq               )
+
+
+/* Busybox messages and functions */
+#if ENABLE_IOCTL_HEX2STR_ERROR
+static int ioctl_alt_func(/*int fd,*/ int cmd, unsigned char *args, int alt, const char *string)
+{
+    if (!ioctl(fd, cmd, args))
+        return 0;
+    args[0] = alt;
+    return bb_ioctl_or_warn(fd, cmd, args, string);
+}
+#define ioctl_alt_or_warn(cmd,args,alt) ioctl_alt_func(cmd,args,alt,#cmd)
+#else
+static int ioctl_alt_func(/*int fd,*/ int cmd, unsigned char *args, int alt)
+{
+    if (!ioctl(fd, cmd, args))
+        return 0;
+    args[0] = alt;
+    return bb_ioctl_or_warn(fd, cmd, args);
+}
+#define ioctl_alt_or_warn(cmd,args,alt) ioctl_alt_func(cmd,args,alt)
+#endif
+
+static void on_off(int value)
+{
+    puts(value ? " (on)" : " (off)");
+}
+
+static void print_flag_on_off(int get_arg, const char *s, unsigned long arg)
+{
+    if (get_arg) {
+        printf(" setting %s to %ld", s, arg);
+        on_off(arg);
+    }
+}
+
+static void print_value_on_off(const char *str, unsigned long argp)
+{
+    printf(" %s\t= %2ld", str, argp);
+    on_off(argp != 0);
+}
+
 #if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const minor_str[MINOR_MAX + 2] = {
+static void print_ascii(const char *p, int length)
+{
+#if BB_BIG_ENDIAN
+#define LE_ONLY(x)
+    enum { ofs = 0 };
+#else
+#define LE_ONLY(x) x
+    /* every 16bit word is big-endian (i.e. inverted) */
+    /* accessing bytes in 1,0, 3,2, 5,4... sequence */
+    int ofs = 1;
+#endif
+
+    length *= 2;
+    /* find first non-space & print it */
+    while (length && p[ofs] != ' ') {
+        p++;
+        LE_ONLY(ofs = -ofs;)
+        length--;
+    }
+    while (length && p[ofs]) {
+        bb_putchar(p[ofs]);
+        p++;
+        LE_ONLY(ofs = -ofs;)
+        length--;
+    }
+    bb_putchar('\n');
+#undef LE_ONLY
+}
+
+static void xprint_ascii(uint16_t *val, int i, const char *string, int n)
+{
+    if (val[i]) {
+        printf("\t%-20s", string);
+        print_ascii((void*)&val[i], n);
+    }
+}
+
+static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode)
+{
+    uint16_t ii;
+    uint8_t err_dma = 0;
+
+    for (ii = 0; ii <= MODE_MAX; ii++) {
+        if (mode_sel & 0x0001) {
+            printf("*%cdma%u ", cc, ii);
+            if (*have_mode)
+                err_dma = 1;
+            *have_mode = 1;
+        } else if (mode_sup & 0x0001)
+            printf("%cdma%u ", cc, ii);
+
+        mode_sup >>= 1;
+        mode_sel >>= 1;
+    }
+    return err_dma;
+}
+
+static const char pkt_str[] ALIGN1 =
+    "Direct-access device" "\0"             /* word 0, bits 12-8 = 00 */
+    "Sequential-access device" "\0"         /* word 0, bits 12-8 = 01 */
+    "Printer" "\0"                          /* word 0, bits 12-8 = 02 */
+    "Processor" "\0"                        /* word 0, bits 12-8 = 03 */
+    "Write-once device" "\0"                /* word 0, bits 12-8 = 04 */
+    "CD-ROM" "\0"                           /* word 0, bits 12-8 = 05 */
+    "Scanner" "\0"                          /* word 0, bits 12-8 = 06 */
+    "Optical memory" "\0"                   /* word 0, bits 12-8 = 07 */
+    "Medium changer" "\0"                   /* word 0, bits 12-8 = 08 */
+    "Communications device" "\0"            /* word 0, bits 12-8 = 09 */
+    "ACS-IT8 device" "\0"                   /* word 0, bits 12-8 = 0a */
+    "ACS-IT8 device" "\0"                   /* word 0, bits 12-8 = 0b */
+    "Array controller" "\0"                 /* word 0, bits 12-8 = 0c */
+    "Enclosure services" "\0"               /* word 0, bits 12-8 = 0d */
+    "Reduced block command device" "\0"     /* word 0, bits 12-8 = 0e */
+    "Optical card reader/writer" "\0"       /* word 0, bits 12-8 = 0f */
+;
+
+static const char ata1_cfg_str[] ALIGN1 =       /* word 0 in ATA-1 mode */
+    "reserved" "\0"                         /* bit 0 */
+    "hard sectored" "\0"                    /* bit 1 */
+    "soft sectored" "\0"                    /* bit 2 */
+    "not MFM encoded " "\0"                 /* bit 3 */
+    "head switch time > 15us" "\0"          /* bit 4 */
+    "spindle motor control option" "\0"     /* bit 5 */
+    "fixed drive" "\0"                      /* bit 6 */
+    "removable drive" "\0"                  /* bit 7 */
+    "disk xfer rate <= 5Mbs" "\0"           /* bit 8 */
+    "disk xfer rate > 5Mbs, <= 10Mbs" "\0"  /* bit 9 */
+    "disk xfer rate > 5Mbs" "\0"            /* bit 10 */
+    "rotational speed tol." "\0"            /* bit 11 */
+    "data strobe offset option" "\0"        /* bit 12 */
+    "track offset option" "\0"              /* bit 13 */
+    "format speed tolerance gap reqd" "\0"  /* bit 14 */
+    "ATAPI"                                 /* bit 14 */
+;
+
+static const char minor_str[] ALIGN1 =
     /* word 81 value: */
-    "Unspecified",                                  /* 0x0000 */
-    "ATA-1 X3T9.2 781D prior to rev.4",             /* 0x0001 */
-    "ATA-1 published, ANSI X3.221-1994",            /* 0x0002 */
-    "ATA-1 X3T9.2 781D rev.4",                      /* 0x0003 */
-    "ATA-2 published, ANSI X3.279-1996",            /* 0x0004 */
-    "ATA-2 X3T10 948D prior to rev.2k",             /* 0x0005 */
-    "ATA-3 X3T10 2008D rev.1",                      /* 0x0006 */
-    "ATA-2 X3T10 948D rev.2k",                      /* 0x0007 */
-    "ATA-3 X3T10 2008D rev.0",                      /* 0x0008 */
-    "ATA-2 X3T10 948D rev.3",                       /* 0x0009 */
-    "ATA-3 published, ANSI X3.298-199x",            /* 0x000a */
-    "ATA-3 X3T10 2008D rev.6",                      /* 0x000b */
-    "ATA-3 X3T13 2008D rev.7 and 7a",               /* 0x000c */
-    "ATA/ATAPI-4 X3T13 1153D rev.6",                /* 0x000d */
-    "ATA/ATAPI-4 T13 1153D rev.13",                 /* 0x000e */
-    "ATA/ATAPI-4 X3T13 1153D rev.7",                /* 0x000f */
-    "ATA/ATAPI-4 T13 1153D rev.18",                 /* 0x0010 */
-    "ATA/ATAPI-4 T13 1153D rev.15",                 /* 0x0011 */
-    "ATA/ATAPI-4 published, ANSI INCITS 317-1998",  /* 0x0012 */
-    "ATA/ATAPI-5 T13 1321D rev.3",                  /* 0x0013 */
-    "ATA/ATAPI-4 T13 1153D rev.14",                 /* 0x0014 */
-    "ATA/ATAPI-5 T13 1321D rev.1",                  /* 0x0015 */
-    "ATA/ATAPI-5 published, ANSI INCITS 340-2000",  /* 0x0016 */
-    "ATA/ATAPI-4 T13 1153D rev.17",                 /* 0x0017 */
-    "ATA/ATAPI-6 T13 1410D rev.0",                  /* 0x0018 */
-    "ATA/ATAPI-6 T13 1410D rev.3a",                 /* 0x0019 */
-    "ATA/ATAPI-7 T13 1532D rev.1",                  /* 0x001a */
-    "ATA/ATAPI-6 T13 1410D rev.2",                  /* 0x001b */
-    "ATA/ATAPI-6 T13 1410D rev.1",                  /* 0x001c */
-    "ATA/ATAPI-7 published, ANSI INCITS 397-2005",  /* 0x001d */
-    "ATA/ATAPI-7 T13 1532D rev.0",                  /* 0x001e */
-    "Reserved"                                      /* 0x001f */
-    "Reserved"                                      /* 0x0020 */
-    "ATA/ATAPI-7 T13 1532D rev.4a",                 /* 0x0021 */
-    "ATA/ATAPI-6 published, ANSI INCITS 361-2002",  /* 0x0022 */
-    "Reserved"                                      /* 0x0023-0xfffe */
-};
-#endif
+    "Unspecified" "\0"                                  /* 0x0000 */
+    "ATA-1 X3T9.2 781D prior to rev.4" "\0"             /* 0x0001 */
+    "ATA-1 published, ANSI X3.221-1994" "\0"            /* 0x0002 */
+    "ATA-1 X3T9.2 781D rev.4" "\0"                      /* 0x0003 */
+    "ATA-2 published, ANSI X3.279-1996" "\0"            /* 0x0004 */
+    "ATA-2 X3T10 948D prior to rev.2k" "\0"             /* 0x0005 */
+    "ATA-3 X3T10 2008D rev.1" "\0"                      /* 0x0006 */
+    "ATA-2 X3T10 948D rev.2k" "\0"                      /* 0x0007 */
+    "ATA-3 X3T10 2008D rev.0" "\0"                      /* 0x0008 */
+    "ATA-2 X3T10 948D rev.3" "\0"                       /* 0x0009 */
+    "ATA-3 published, ANSI X3.298-199x" "\0"            /* 0x000a */
+    "ATA-3 X3T10 2008D rev.6" "\0"                      /* 0x000b */
+    "ATA-3 X3T13 2008D rev.7 and 7a" "\0"               /* 0x000c */
+    "ATA/ATAPI-4 X3T13 1153D rev.6" "\0"                /* 0x000d */
+    "ATA/ATAPI-4 T13 1153D rev.13" "\0"                 /* 0x000e */
+    "ATA/ATAPI-4 X3T13 1153D rev.7" "\0"                /* 0x000f */
+    "ATA/ATAPI-4 T13 1153D rev.18" "\0"                 /* 0x0010 */
+    "ATA/ATAPI-4 T13 1153D rev.15" "\0"                 /* 0x0011 */
+    "ATA/ATAPI-4 published, ANSI INCITS 317-1998" "\0"  /* 0x0012 */
+    "ATA/ATAPI-5 T13 1321D rev.3" "\0"                  /* 0x0013 */
+    "ATA/ATAPI-4 T13 1153D rev.14" "\0"                 /* 0x0014 */
+    "ATA/ATAPI-5 T13 1321D rev.1" "\0"                  /* 0x0015 */
+    "ATA/ATAPI-5 published, ANSI INCITS 340-2000" "\0"  /* 0x0016 */
+    "ATA/ATAPI-4 T13 1153D rev.17" "\0"                 /* 0x0017 */
+    "ATA/ATAPI-6 T13 1410D rev.0" "\0"                  /* 0x0018 */
+    "ATA/ATAPI-6 T13 1410D rev.3a" "\0"                 /* 0x0019 */
+    "ATA/ATAPI-7 T13 1532D rev.1" "\0"                  /* 0x001a */
+    "ATA/ATAPI-6 T13 1410D rev.2" "\0"                  /* 0x001b */
+    "ATA/ATAPI-6 T13 1410D rev.1" "\0"                  /* 0x001c */
+    "ATA/ATAPI-7 published, ANSI INCITS 397-2005" "\0"  /* 0x001d */
+    "ATA/ATAPI-7 T13 1532D rev.0" "\0"                  /* 0x001e */
+    "reserved" "\0"                                     /* 0x001f */
+    "reserved" "\0"                                     /* 0x0020 */
+    "ATA/ATAPI-7 T13 1532D rev.4a" "\0"                 /* 0x0021 */
+    "ATA/ATAPI-6 published, ANSI INCITS 361-2002" "\0"  /* 0x0022 */
+    "reserved"                                          /* 0x0023-0xfffe */
+;
 static const char actual_ver[MINOR_MAX + 2] ALIGN1 = {
        /* word 81 value: */
@@ -320 +600 @@
 };
 
-/* words 82-84: cmds/feats supported */
-#define CMDS_W82        0x77ff  /* word 82: defined command locations*/
-#define CMDS_W83        0x3fff  /* word 83: defined command locations*/
-#define CMDS_W84        0x002f  /* word 83: defined command locations*/
-#define SUPPORT_48_BIT      0x0400
-#define NUM_CMD_FEAT_STR    48
-
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const cmd_feat_str[] = {
-    "",                 /* word 82 bit 15: obsolete  */
-    "NOP cmd",              /* word 82 bit 14 */
-    "READ BUFFER cmd",          /* word 82 bit 13 */
-    "WRITE BUFFER cmd",         /* word 82 bit 12 */
-    "",                 /* word 82 bit 11: obsolete  */
-    "Host Protected Area feature set",  /* word 82 bit 10 */
-    "DEVICE RESET cmd",         /* word 82 bit  9 */
-    "SERVICE interrupt",            /* word 82 bit  8 */
-    "Release interrupt",            /* word 82 bit  7 */
-    "Look-ahead",               /* word 82 bit  6 */
-    "Write cache",              /* word 82 bit  5 */
-    "PACKET command feature set",       /* word 82 bit  4 */
-    "Power Management feature set",     /* word 82 bit  3 */
-    "Removable Media feature set",      /* word 82 bit  2 */
-    "Security Mode feature set",        /* word 82 bit  1 */
-    "SMART feature set",            /* word 82 bit  0 */
-                        /* -------------- */
-    "",                 /* word 83 bit 15: !valid bit */
-    "",                 /* word 83 bit 14:  valid bit */
-    "FLUSH CACHE EXT cmd",          /* word 83 bit 13 */
-    "Mandatory FLUSH CACHE cmd ",       /* word 83 bit 12 */
-    "Device Configuration Overlay feature set ",
-    "48-bit Address feature set ",      /* word 83 bit 10 */
-    "",
-    "SET MAX security extension",       /* word 83 bit  8 */
-    "Address Offset Reserved Area Boot",    /* word 83 bit  7 */
-    "SET FEATURES subcommand required to spinup after power up",
-    "Power-Up In Standby feature set",  /* word 83 bit  5 */
-    "Removable Media Status Notification feature set",
-    "Adv. Power Management feature set",    /* word 83 bit  3 */
-    "CFA feature set",          /* word 83 bit  2 */
-    "READ/WRITE DMA QUEUED",        /* word 83 bit  1 */
-    "DOWNLOAD MICROCODE cmd",       /* word 83 bit  0 */
-                        /* -------------- */
-    "",                 /* word 84 bit 15: !valid bit */
-    "",                 /* word 84 bit 14:  valid bit */
-    "",                 /* word 84 bit 13:  reserved */
-    "",                 /* word 84 bit 12:  reserved */
-    "",                 /* word 84 bit 11:  reserved */
-    "",                 /* word 84 bit 10:  reserved */
-    "",                 /* word 84 bit  9:  reserved */
-    "",                 /* word 84 bit  8:  reserved */
-    "",                 /* word 84 bit  7:  reserved */
-    "",                 /* word 84 bit  6:  reserved */
-    "General Purpose Logging feature set",  /* word 84 bit  5 */
-    "",                 /* word 84 bit  4:  reserved */
-    "Media Card Pass Through Command feature set ",
-    "Media serial number ",         /* word 84 bit  2 */
-    "SMART self-test ",         /* word 84 bit  1 */
-    "SMART error logging "          /* word 84 bit  0 */
-};
-
-static void identify(uint16_t *id_supplied) ATTRIBUTE_NORETURN;
-static void identify_from_stdin(void) ATTRIBUTE_NORETURN;
-#else
-void identify_from_stdin(void);
-#endif
-
-
-/* words 85-87: cmds/feats enabled */
-/* use cmd_feat_str[] to display what commands and features have
- * been enabled with words 85-87
- */
-
-/* words 89, 90, SECU ERASE TIME */
-#define ERASE_BITS      0x00ff
-
-/* word 92: master password revision */
-/* NOVAL_0 or  NOVAL_1 means no support for master password revision */
-
-/* word 93: hw reset result */
-#define CBLID           0x2000  /* CBLID status */
-#define RST0            0x0001  /* 1=reset to device #0 */
-#define DEV_DET         0x0006  /* how device num determined */
-#define JUMPER_VAL      0x0002  /* device num determined by jumper */
-#define CSEL_VAL        0x0004  /* device num determined by CSEL_VAL */
-
-/* word 127: removable media status notification feature set support */
-#define RM_STAT_BITS    0x0003
-#define RM_STAT_SUP     0x0001
-
-/* word 128: security */
-#define SECU_ENABLED    0x0002
-#define SECU_LEVEL      0x0010
-#define NUM_SECU_STR    6
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const secu_str[] = {
-    "supported",            /* word 128, bit 0 */
-    "enabled",          /* word 128, bit 1 */
-    "locked",           /* word 128, bit 2 */
-    "frozen",           /* word 128, bit 3 */
-    "expired: security count",  /* word 128, bit 4 */
-    "supported: enhanced erase" /* word 128, bit 5 */
-};
-#endif
-
-/* word 160: CFA power mode */
-#define VALID_W160              0x8000  /* 1=word valid */
-#define PWR_MODE_REQ            0x2000  /* 1=CFA power mode req'd by some cmds*/
-#define PWR_MODE_OFF            0x1000  /* 1=CFA power moded disabled */
-#define MAX_AMPS                0x0fff  /* value = max current in ma */
-
-/* word 255: integrity */
-#define SIG                     0x00ff  /* signature location */
-#define SIG_VAL                 0x00a5  /* signature value */
-
-#define TIMING_MB               64
-#define TIMING_BUF_MB           1
-#define TIMING_BUF_BYTES        (TIMING_BUF_MB * 1024 * 1024)
-#define BUFCACHE_FACTOR         2
-
-#undef DO_FLUSHCACHE            /* under construction: force cache flush on -W0 */
-
-/* Busybox messages and functions */
-#if ENABLE_IOCTL_HEX2STR_ERROR
-static int ioctl_alt_func(int fd, int cmd, unsigned char *args, int alt, const char *string)
-{
-    if (!ioctl(fd, cmd, args))
-        return 0;
-    args[0] = alt;
-    return bb_ioctl_or_warn(fd, cmd, args, string);
-}
-#define ioctl_alt_or_warn(fd,cmd,args,alt) ioctl_alt_func(fd,cmd,args,alt,#cmd)
-#else
-static int ioctl_alt_func(int fd, int cmd, unsigned char *args, int alt)
-{
-    if (!ioctl(fd, cmd, args))
-        return 0;
-    args[0] = alt;
-    return bb_ioctl_or_warn(fd, cmd, args);
-}
-#define ioctl_alt_or_warn(fd,cmd,args,alt) ioctl_alt_func(fd,cmd,args,alt)
-#endif
-
-static void on_off(int value)
-{
-    puts(value ? " (on)" : " (off)");
-}
-
-static void print_flag_on_off(int get_arg, const char *s, unsigned long arg)
-{
-    if (get_arg) {
-        printf(" setting %s to %ld", s, arg);
-        on_off(arg);
-    }
-}
-
-static void print_value_on_off(const char *str, unsigned long argp)
-{
-    printf(" %s\t= %2ld", str, argp);
-    on_off(argp != 0);
-}
-
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static void print_ascii(uint16_t *p, uint8_t length);
-
-static void xprint_ascii(uint16_t *val, int i, const char *string, int n)
-{
-    if (val[i]) {
-        printf("\t%-20s", string);
-        print_ascii(&val[i], n);
-    }
-}
-#endif
-/* end of busybox specific stuff */
-
-#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode)
-{
-    uint16_t ii;
-    uint8_t err_dma = 0;
-
-    for (ii = 0; ii <= MODE_MAX; ii++) {
-        if (mode_sel & 0x0001) {
-            printf("*%cdma%u ", cc, ii);
-            if (*have_mode)
-                err_dma = 1;
-            *have_mode = 1;
-        } else if (mode_sup & 0x0001)
-            printf("%cdma%u ", cc, ii);
-
-        mode_sup >>= 1;
-        mode_sel >>= 1;
-    }
-    return err_dma;
-}
-
-static void print_ascii(uint16_t *p, uint8_t length)
-{
-    uint8_t ii;
-    char cl;
-
-    /* find first non-space & print it */
-    for (ii = 0; ii < length; ii++) {
-        if ((char)((*p)>>8) != ' ')
-            break;
-        cl = (char)(*p);
-        if (cl != ' ') {
-            if (cl != '\0')
-                printf("%c", cl);
-            p++;
-            ii++;
-            break;
-        }
-        p++;
-    }
-    /* print the rest */
-    for (; ii< length; ii++) {
-        if (!(*p))
-            break; /* some older devices have NULLs */
-        printf("%c%c", (char)((*p)>>8), (char)(*p));
-        p++;
-    }
-    puts("");
-}
+static const char cmd_feat_str[] ALIGN1 =
+    "" "\0"                                     /* word 82 bit 15: obsolete  */
+    "NOP cmd" "\0"                              /* word 82 bit 14 */
+    "READ BUFFER cmd" "\0"                      /* word 82 bit 13 */
+    "WRITE BUFFER cmd" "\0"                     /* word 82 bit 12 */
+    "" "\0"                                     /* word 82 bit 11: obsolete  */
+    "Host Protected Area feature set" "\0"      /* word 82 bit 10 */
+    "DEVICE RESET cmd" "\0"                     /* word 82 bit  9 */
+    "SERVICE interrupt" "\0"                    /* word 82 bit  8 */
+    "Release interrupt" "\0"                    /* word 82 bit  7 */
+    "Look-ahead" "\0"                           /* word 82 bit  6 */
+    "Write cache" "\0"                          /* word 82 bit  5 */
+    "PACKET command feature set" "\0"           /* word 82 bit  4 */
+    "Power Management feature set" "\0"         /* word 82 bit  3 */
+    "Removable Media feature set" "\0"          /* word 82 bit  2 */
+    "Security Mode feature set" "\0"            /* word 82 bit  1 */
+    "SMART feature set" "\0"                    /* word 82 bit  0 */
+                                                /* -------------- */
+    "" "\0"                                     /* word 83 bit 15: !valid bit */
+    "" "\0"                                     /* word 83 bit 14:  valid bit */
+    "FLUSH CACHE EXT cmd" "\0"                  /* word 83 bit 13 */
+    "Mandatory FLUSH CACHE cmd " "\0"           /* word 83 bit 12 */
+    "Device Configuration Overlay feature set " "\0"
+    "48-bit Address feature set " "\0"          /* word 83 bit 10 */
+    "" "\0"
+    "SET MAX security extension" "\0"           /* word 83 bit  8 */
+    "Address Offset Reserved Area Boot" "\0"    /* word 83 bit  7 */
+    "SET FEATURES subcommand required to spinup after power up" "\0"
+    "Power-Up In Standby feature set" "\0"      /* word 83 bit  5 */
+    "Removable Media Status Notification feature set" "\0"
+    "Adv. Power Management feature set" "\0"    /* word 83 bit  3 */
+    "CFA feature set" "\0"                      /* word 83 bit  2 */
+    "READ/WRITE DMA QUEUED" "\0"                /* word 83 bit  1 */
+    "DOWNLOAD MICROCODE cmd" "\0"               /* word 83 bit  0 */
+                                                /* -------------- */
+    "" "\0"                                     /* word 84 bit 15: !valid bit */
+    "" "\0"                                     /* word 84 bit 14:  valid bit */
+    "" "\0"                                     /* word 84 bit 13:  reserved */
+    "" "\0"                                     /* word 84 bit 12:  reserved */
+    "" "\0"                                     /* word 84 bit 11:  reserved */
+    "" "\0"                                     /* word 84 bit 10:  reserved */
+    "" "\0"                                     /* word 84 bit  9:  reserved */
+    "" "\0"                                     /* word 84 bit  8:  reserved */
+    "" "\0"                                     /* word 84 bit  7:  reserved */
+    "" "\0"                                     /* word 84 bit  6:  reserved */
+    "General Purpose Logging feature set" "\0"  /* word 84 bit  5 */
+    "" "\0"                                     /* word 84 bit  4:  reserved */
+    "Media Card Pass Through Command feature set " "\0"
+    "Media serial number " "\0"                 /* word 84 bit  2 */
+    "SMART self-test " "\0"                     /* word 84 bit  1 */
+    "SMART error logging "                      /* word 84 bit  0 */
+;
+
+static const char secu_str[] ALIGN1 =
+    "supported" "\0"                /* word 128, bit 0 */
+    "enabled" "\0"                  /* word 128, bit 1 */
+    "locked" "\0"                   /* word 128, bit 2 */
+    "frozen" "\0"                   /* word 128, bit 3 */
+    "expired: security count" "\0"  /* word 128, bit 4 */
+    "supported: enhanced erase"     /* word 128, bit 5 */
+;
 
 // Parse 512 byte disk identification block and print much crap.
-
-static void identify(uint16_t *id_supplied)
-{
-    uint16_t buf[256];
-    uint16_t *val, ii, jj, kk;
+static void identify(uint16_t *val) NORETURN;
+static void identify(uint16_t *val)
+{
+    uint16_t ii, jj, kk;
     uint16_t like_std = 1, std = 0, min_std = 0xffff;
     uint16_t dev = NO_DEV, eqpt = NO_DEV;
@@ -558 +674 @@
     uint64_t bbbig; /* (:) */
     const char *strng;
-
-    // Adjust for endianness if necessary.
-
-    if (BB_BIG_ENDIAN) {
-        swab(id_supplied, buf, sizeof(buf));
-        val = buf;
-    } else
-        val = id_supplied;
-
-    chksum &= 0xff;
-
-    /* check if we recognise the device type */
-    puts("");
+#if BB_BIG_ENDIAN
+    uint16_t buf[256];
+
+    // Adjust for endianness
+    swab(val, buf, sizeof(buf));
+    val = buf;
+#endif
+    /* check if we recognize the device type */
+    bb_putchar('\n');
     if (!(val[GEN_CONFIG] & NOT_ATA)) {
         dev = ATA_DEV;
@@ -581 +693 @@
         dev = ATAPI_DEV;
         eqpt = (val[GEN_CONFIG] & EQPT_TYPE) >> SHIFT_EQPT;
-        printf("ATAPI %s, with ", pkt_str[eqpt]);
+        printf("ATAPI %s, with ", eqpt <= 0xf ? nth_string(pkt_str, eqpt) : "unknown");
         like_std = 3;
     } else
-        /*"Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n"*/
+        /* "Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n" */
         bb_error_msg_and_die("unknown device type");
 
@@ -619 +731 @@
             if (like_std < 3) like_std = 3;
             std = actual_ver[val[MINOR]];
-            if (std) printf("\n\tUsed: %s ", minor_str[val[MINOR]]);
-
+            if (std)
+                printf("\n\tUsed: %s ", nth_string(minor_str, val[MINOR]));
         }
         /* looks like when they up-issue the std, they obsolete one;
@@ -687 +799 @@
             printf("& some of %u\n", like_std);
         else
-            puts("");
+            bb_putchar('\n');
     } else {
         /* TBD: do CDROM stuff more thoroughly.  For now... */
@@ -704 +816 @@
             }
         }
-        printf("%s\n", kk ? "" : "\n\tLikely used CD-ROM ATAPI-1");
+        puts(kk ? "" : "\n\tLikely used CD-ROM ATAPI-1");
         /* the cdrom stuff is more like ATA-2 than anything else, so: */
         like_std = 2;
@@ -718 +830 @@
         for (ii = 1; ii < 15; ii++) {
             if (jj & 0x0001)
-                printf("\t%s\n", ata1_cfg_str[ii]);
+                printf("\t%s\n", nth_string(ata1_cfg_str, ii));
             jj >>=1;
         }
@@ -730 +842 @@
             strng ="50us";
         else
-            strng = "Unknown";
+            strng = "unknown";
         printf("\tDRQ response: %s\n\tPacket size: ", strng); /* Data Request (DRQ) */
 
@@ -738 +850 @@
             strng = "16 bytes";
         else
-            strng = "Unknown";
+            strng = "unknown";
         puts(strng);
     } else {
         /* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */
         ll = (uint32_t)val[LBA_SECTS_MSB] << 16 | val[LBA_SECTS_LSB];
-        mm = 0; bbbig = 0;
+        mm = 0;
+        bbbig = 0;
         if ((ll > 0x00FBFC10) && (!val[LCYLS]))
             printf("\tCHS addressing not supported\n");
         else {
             jj = val[WHATS_VALID] & OK_W54_58;
-            printf("\tLogical\t\tmax\tcurrent\n\tcylinders\t%u\t%u\n\theads\t\t%u\t%u\n\tsectors/track\t%u\t%u\n\t--\n",
-                    val[LCYLS],jj?val[LCYLS_CUR]:0, val[LHEADS],jj?val[LHEADS_CUR]:0, val[LSECTS],jj?val[LSECTS_CUR]:0);
+            printf("\tLogical\t\tmax\tcurrent\n"
+                "\tcylinders\t%u\t%u\n"
+                "\theads\t\t%u\t%u\n"
+                "\tsectors/track\t%u\t%u\n"
+                "\t--\n",
+                val[LCYLS],
+                jj ? val[LCYLS_CUR] : 0,
+                val[LHEADS],
+                jj ? val[LHEADS_CUR] : 0,
+                val[LSECTS],
+                jj ? val[LSECTS_CUR] : 0);
 
             if ((min_std == 1) && (val[TRACK_BYTES] || val[SECT_BYTES]))
-                printf("\tbytes/track: %u\tbytes/sector: %u\n", val[TRACK_BYTES], val[SECT_BYTES]);
+                printf("\tbytes/track: %u\tbytes/sector: %u\n",
+                    val[TRACK_BYTES], val[SECT_BYTES]);
 
             if (jj) {
@@ -787 +910 @@
             printf("(%"PRIu64" GB)\n", bbbig/1000);
         else
-            puts("");
+            bb_putchar('\n');
     }
 
@@ -794 +917 @@
 
     if (dev == ATAPI_DEV) {
-        if (eqpt != CDROM && (val[CAPAB_0] & CMD_Q_SUP)) printf("Cmd queuing, ");
-        if (val[CAPAB_0] & OVLP_SUP) printf("Cmd overlap, ");
+        if (eqpt != CDROM && (val[CAPAB_0] & CMD_Q_SUP))
+            printf("Cmd queuing, ");
+        if (val[CAPAB_0] & OVLP_SUP)
+            printf("Cmd overlap, ");
     }
     if (val[CAPAB_0] & LBA_SUP) printf("LBA, ");
@@ -801 +926 @@
     if (like_std != 1) {
         printf("IORDY%s(can%s be disabled)\n",
-                !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "",
-                (val[CAPAB_0] & IORDY_OFF) ? "" :"not");
+            !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "",
+            (val[CAPAB_0] & IORDY_OFF) ? "" :"not");
     } else
         printf("no IORDY\n");
@@ -808 +933 @@
     if ((like_std == 1) && val[BUF_TYPE]) {
         printf("\tBuffer type: %04x: %s%s\n", val[BUF_TYPE],
-                (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector",
-                (val[BUF_TYPE] > 2) ? " with read caching ability" : "");
+            (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector",
+            (val[BUF_TYPE] > 2) ? " with read caching ability" : "");
     }
 
@@ -826 +951 @@
             printf("\tCan%s perform double-word IO\n", (!val[DWORD_IO]) ? "not" : "");
         else {
-            printf("\tStandby timer values: spec'd by %s", (val[CAPAB_0] & STD_STBY) ? "Standard" : "Vendor");
+            printf("\tStandby timer values: spec'd by %s",
+                (val[CAPAB_0] & STD_STBY) ? "standard" : "vendor");
             if ((like_std > 3) && ((val[CAPAB_1] & VALID) == VALID_VAL))
-                printf(", %s device specific minimum\n", (val[CAPAB_1] & MIN_STANDBY_TIMER) ? "with" : "no");
+                printf(", %s device specific minimum\n",
+                    (val[CAPAB_1] & MIN_STANDBY_TIMER) ? "with" : "no");
             else
-                puts("");
+                bb_putchar('\n');
         }
         printf("\tR/W multiple sector transfer: ");
@@ -856 +983 @@
         if (like_std > 5 && val[ACOUSTIC]) {
             printf("\tRecommended acoustic management value: %u, current value: %u\n",
-                    (val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff);
+                (val[ACOUSTIC] >> 8) & 0x00ff,
+                val[ACOUSTIC] & 0x00ff);
         }
     } else {
@@ -865 +993 @@
         if (val[PKT_REL] || val[SVC_NBSY]) {
             printf("\tOverlap support:");
-            if (val[PKT_REL]) printf(" %uus to release bus.", val[PKT_REL]);
-            if (val[SVC_NBSY]) printf(" %uus to clear BSY after SERVICE cmd.", val[SVC_NBSY]);
-            puts("");
+            if (val[PKT_REL])
+                printf(" %uus to release bus.", val[PKT_REL]);
+            if (val[SVC_NBSY])
+                printf(" %uus to clear BSY after SERVICE cmd.",
+                    val[SVC_NBSY]);
+            bb_putchar('\n');
         }
     }
@@ -894 +1025 @@
         }
         if (err_dma || !have_mode) printf("(?)");
-        puts("");
+        bb_putchar('\n');
 
         if ((dev == ATAPI_DEV) && (eqpt != CDROM) && (val[CAPAB_0] & DMA_IL_SUP))
@@ -905 +1036 @@
             if (val[DMA_TIME_MIN]) printf(" min=%uns", val[DMA_TIME_MIN]);
             if (val[DMA_TIME_NORM]) printf(" recommended=%uns", val[DMA_TIME_NORM]);
-            puts("");
+            bb_putchar('\n');
         }
     }
@@ -919 +1050 @@
             jj >>=1;
         }
-        puts("");
+        bb_putchar('\n');
     } else if (((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE)) {
         for (ii = 0; ii <= val[PIO_MODE]>>8; ii++)
             printf("pio%d ", ii);
-        puts("");
+        bb_putchar('\n');
     } else
-        printf("unknown\n");
+        puts("unknown");
 
     if (val[WHATS_VALID] & OK_W64_70) {
         if (val[PIO_NO_FLOW] || val[PIO_FLOW]) {
             printf("\t\tCycle time:");
-            if (val[PIO_NO_FLOW]) printf(" no flow control=%uns", val[PIO_NO_FLOW]);
-            if (val[PIO_FLOW]) printf("  IORDY flow control=%uns", val[PIO_FLOW]);
-            puts("");
+            if (val[PIO_NO_FLOW])
+                printf(" no flow control=%uns", val[PIO_NO_FLOW]);
+            if (val[PIO_FLOW])
+                printf("  IORDY flow control=%uns", val[PIO_FLOW]);
+            bb_putchar('\n');
         }
     }
 
     if ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) {
-        printf("Commands/features:\n\tEnabled\tSupported:\n");
+        printf("Commands/features:\n"
+            "\tEnabled\tSupported:\n");
         jj = val[CMDS_SUPP_0];
         kk = val[CMDS_EN_0];
         for (ii = 0; ii < NUM_CMD_FEAT_STR; ii++) {
-            if ((jj & 0x8000) && (*cmd_feat_str[ii] != '\0')) {
-                printf("\t%s\t%s\n", (kk & 0x8000) ? "   *" : "", cmd_feat_str[ii]);
+            const char *feat_str = nth_string(cmd_feat_str, ii);
+            if ((jj & 0x8000) && (*feat_str != '\0')) {
+                printf("\t%s\t%s\n", (kk & 0x8000) ? "   *" : "", feat_str);
             }
             jj <<= 1;
@@ -958 +1093 @@
     /* Removable Media Status Notification feature set */
     if ((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP)
-        printf("\t%s supported\n", cmd_feat_str[27]);
+        printf("\t%s supported\n", nth_string(cmd_feat_str, 27));
 
     /* security */
@@ -970 +1105 @@
         if (jj) {
             for (ii = 0; ii < NUM_SECU_STR; ii++) {
-                printf("\t%s\t%s\n", (!(jj & 0x0001)) ? "not" : "",  secu_str[ii]);
+                printf("\t%s\t%s\n",
+                    (!(jj & 0x0001)) ? "not" : "",
+                    nth_string(secu_str, ii));
                 jj >>=1;
             }
             if (val[SECU_STATUS] & SECU_ENABLED) {
-                printf("\tSecurity level %s\n", (val[SECU_STATUS] & SECU_LEVEL) ? "maximum" : "high");
+                printf("\tSecurity level %s\n",
+                    (val[SECU_STATUS] & SECU_LEVEL) ? "maximum" : "high");
             }
         }
@@ -980 +1118 @@
         kk =  val[ENH_ERASE_TIME] & ERASE_BITS;
         if (jj || kk) {
-            printf("\t");
+            bb_putchar('\t');
             if (jj) printf("%umin for %sSECURITY ERASE UNIT. ", jj==ERASE_BITS ? 508 : jj<<1, "");
             if (kk) printf("%umin for %sSECURITY ERASE UNIT. ", kk==ERASE_BITS ? 508 : kk<<1, "ENHANCED ");
-            puts("");
+            bb_putchar('\n');
         }
     }
@@ -990 +1128 @@
     jj = val[HWRST_RSLT];
     if ((jj & VALID) == VALID_VAL) {
-        if (!(oo = (jj & RST0)))
+        oo = (jj & RST0);
+        if (!oo)
             jj >>= 8;
         if ((jj & DEV_DET) == JUMPER_VAL)
@@ -998 +1137 @@
         else
             strng = "";
-        printf("HW reset results:\n\tCBLID- %s Vih\n\tDevice num = %i%s\n",
-                (val[HWRST_RSLT] & CBLID) ? "above" : "below", !(oo), strng);
+        printf("HW reset results:\n"
+            "\tCBLID- %s Vih\n"
+            "\tDevice num = %i%s\n",
+            (val[HWRST_RSLT] & CBLID) ? "above" : "below",
+            !(oo), strng);
     }
 
@@ -1005 +1147 @@
     if ((like_std > 4) && (eqpt != CDROM)) {
         if (val[CFA_PWR_MODE] & VALID_W160) {
-            printf("CFA power mode 1:\n\t%s%s\n", (val[CFA_PWR_MODE] & PWR_MODE_OFF) ? "disabled" : "enabled",
-                    (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : "");
-
+            printf("CFA power mode 1:\n"
+                "\t%s%s\n",
+                (val[CFA_PWR_MODE] & PWR_MODE_OFF) ? "disabled" : "enabled",
+                (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : "");
             if (val[CFA_PWR_MODE] & MAX_AMPS)
                 printf("\tMaximum current = %uma\n", val[CFA_PWR_MODE] & MAX_AMPS);
@@ -1018 +1161 @@
     exit(EXIT_SUCCESS);
 }
-#endif
-
-static smallint get_identity, get_geom;
-static smallint do_flush;
-static smallint do_ctimings, do_timings;
-static smallint reread_partn;
-
-static smallint set_piomode, noisy_piomode;
-static smallint set_readahead, get_readahead;
-static smallint set_readonly, get_readonly;
-static smallint set_unmask, get_unmask;
-static smallint set_mult, get_mult;
-static smallint set_dma_q, get_dma_q;
-static smallint set_nowerr, get_nowerr;
-static smallint set_keep, get_keep;
-static smallint set_io32bit, get_io32bit;
-static int piomode;
-static unsigned long Xreadahead;
-static unsigned long readonly;
-static unsigned long unmask;
-static unsigned long mult;
-static unsigned long dma_q;
-static unsigned long nowerr;
-static unsigned long keep;
-static unsigned long io32bit;
-#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
-static unsigned long dma;
-static smallint set_dma, get_dma;
-#endif
-#ifdef HDIO_DRIVE_CMD
-static smallint set_xfermode, get_xfermode;
-static smallint set_dkeep, get_dkeep;
-static smallint set_standby, get_standby;
-static smallint set_lookahead, get_lookahead;
-static smallint set_prefetch, get_prefetch;
-static smallint set_defects, get_defects;
-static smallint set_wcache, get_wcache;
-static smallint set_doorlock, get_doorlock;
-static smallint set_seagate, get_seagate;
-static smallint set_standbynow, get_standbynow;
-static smallint set_sleepnow, get_sleepnow;
-static smallint get_powermode;
-static smallint set_apmmode, get_apmmode;
-static int xfermode_requested;
-static unsigned long dkeep;
-static unsigned long standby_requested;
-static unsigned long lookahead;
-static unsigned long prefetch;
-static unsigned long defects;
-static unsigned long wcache;
-static unsigned long doorlock;
-static unsigned long apmmode;
-#endif
-USE_FEATURE_HDPARM_GET_IDENTITY(        static smallint get_IDentity;)
-USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  static smallint set_busstate, get_busstate;)
-USE_FEATURE_HDPARM_HDIO_DRIVE_RESET(    static smallint perform_reset;)
-USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  static smallint perform_tristate;)
-USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(static smallint unregister_hwif;)
-USE_FEATURE_HDPARM_HDIO_SCAN_HWIF(      static smallint scan_hwif;)
-USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  static unsigned long busstate;)
-USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(  static unsigned long tristate;)
-USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(static unsigned long hwif;)
-#if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
-static unsigned long hwif_data;
-static unsigned long hwif_ctrl;
-static unsigned long hwif_irq;
 #endif
 
@@ -1098 +1175 @@
 
 #if ENABLE_FEATURE_HDPARM_GET_IDENTITY
-static const char *const cfg_str[] = {
-    "",      "HardSect",   "SoftSect",   "NotMFM",
-    "HdSw>15uSec", "SpinMotCtl", "Fixed",     "Removeable",
-    "DTR<=5Mbs",   "DTR>5Mbs",   "DTR>10Mbs", "RotSpdTol>.5%",
-    "dStbOff",     "TrkOff",     "FmtGapReq", "nonMagnetic"
-};
-
-static const char *const BuffType[] = {
-    "Unknown", "1Sect", "DualPort", "DualPortCache"
-};
-
-static void dump_identity(const struct hd_driveid *id)
+static const char cfg_str[] ALIGN1 =
+    """\0"            "HardSect""\0"   "SoftSect""\0"  "NotMFM""\0"
+    "HdSw>15uSec""\0" "SpinMotCtl""\0" "Fixed""\0"     "Removeable""\0"
+    "DTR<=5Mbs""\0"   "DTR>5Mbs""\0"   "DTR>10Mbs""\0" "RotSpdTol>.5%""\0"
+    "dStbOff""\0"     "TrkOff""\0"     "FmtGapReq""\0" "nonMagnetic"
+;
+
+static const char BuffType[] ALIGN1 =
+    "unknown""\0"     "1Sect""\0"      "DualPort""\0"  "DualPortCache"
+;
+
+static NOINLINE void dump_identity(const struct hd_driveid *id)
 {
     int i;
-    const unsigned short int *id_regs = (const void*) id;
+    const unsigned short *id_regs = (const void*) id;
 
     printf("\n Model=%.40s, FwRev=%.8s, SerialNo=%.20s\n Config={",
@@ -1118 +1195 @@
     for (i = 0; i <= 15; i++) {
         if (id->config & (1<<i))
-            printf(" %s", cfg_str[i]);
+            printf(" %s", nth_string(cfg_str, i));
     }
     printf(" }\n RawCHS=%u/%u/%u, TrkSize=%u, SectSize=%u, ECCbytes=%u\n"
-            " BuffType=(%u) %s, BuffSize=%ukB, MaxMultSect=%u",
-                id->cyls, id->heads, id->sectors, id->track_bytes,
-                id->sector_bytes, id->ecc_bytes,
-                id->buf_type, BuffType[(id->buf_type > 3) ? 0 :  id->buf_type],
-                id->buf_size/2, id->max_multsect);
+        " BuffType=(%u) %s, BuffSize=%ukB, MaxMultSect=%u",
+        id->cyls, id->heads, id->sectors, id->track_bytes,
+        id->sector_bytes, id->ecc_bytes,
+        id->buf_type,
+        nth_string(BuffType, (id->buf_type > 3) ? 0 : id->buf_type),
+        id->buf_size/2, id->max_multsect);
     if (id->max_multsect) {
         printf(", MultSect=");
@@ -1135 +1213 @@
             printf("off");
     }
-    puts("");
+    bb_putchar('\n');
 
     if (!(id->field_valid & 1))
@@ -1150 +1228 @@
         printf(", LBAsects=%u", id->lba_capacity);
 
-    printf("\n IORDY=%s", (id->capability & 8) ? (id->capability & 4) ?  "on/off" : "yes" : "no");
+    printf("\n IORDY=%s",
+        (id->capability & 8)
+            ? ((id->capability & 4) ? "on/off" : "yes")
+            : "no");
 
     if (((id->capability & 8) || (id->field_valid & 2)) && (id->field_valid & 2))
@@ -1165 +1246 @@
     }
     if (id->field_valid & 2) {
-        if (id->eide_pio_modes & 1) printf("pio3 ");
-        if (id->eide_pio_modes & 2) printf("pio4 ");
-        if (id->eide_pio_modes &~3) printf("pio? ");
+        static const masks_labels_t pio_modes = {
+            .masks = { 1, 2, ~3 },
+            .labels = "pio3 \0""pio4 \0""pio? \0",
+        };
+        print_flags(&pio_modes, id->eide_pio_modes);
     }
     if (id->capability & 1) {
         if (id->dma_1word | id->dma_mword) {
+            static const int dma_wmode_masks[] = { 0x100, 1, 0x200, 2, 0x400, 4, 0xf800, 0xf8 };
             printf("\n DMA modes:  ");
-            if (id->dma_1word & 0x100) printf("*");
-            if (id->dma_1word & 1) printf("sdma0 ");
-            if (id->dma_1word & 0x200) printf("*");
-            if (id->dma_1word & 2) printf("sdma1 ");
-            if (id->dma_1word & 0x400) printf("*");
-            if (id->dma_1word & 4) printf("sdma2 ");
-            if (id->dma_1word & 0xf800) printf("*");
-            if (id->dma_1word & 0xf8) printf("sdma? ");
-            if (id->dma_mword & 0x100) printf("*");
-            if (id->dma_mword & 1) printf("mdma0 ");
-            if (id->dma_mword & 0x200) printf("*");
-            if (id->dma_mword & 2) printf("mdma1 ");
-            if (id->dma_mword & 0x400) printf("*");
-            if (id->dma_mword & 4) printf("mdma2 ");
-            if (id->dma_mword & 0xf800) printf("*");
-            if (id->dma_mword & 0xf8) printf("mdma? ");
+            print_flags_separated(dma_wmode_masks,
+                "*\0""sdma0 \0""*\0""sdma1 \0""*\0""sdma2 \0""*\0""sdma? \0",
+                id->dma_1word, NULL);
+            print_flags_separated(dma_wmode_masks,
+                "*\0""mdma0 \0""*\0""mdma1 \0""*\0""mdma2 \0""*\0""mdma? \0",
+                id->dma_mword, NULL);
         }
     }
     if (((id->capability & 8) || (id->field_valid & 2)) && id->field_valid & 4) {
+        static const masks_labels_t ultra_modes1 = {
+            .masks = { 0x100, 0x001, 0x200, 0x002, 0x400, 0x004 },
+            .labels = "*\0""udma0 \0""*\0""udma1 \0""*\0""udma2 \0",
+        };
+
         printf("\n UDMA modes: ");
-        if (id->dma_ultra & 0x100) printf("*");
-        if (id->dma_ultra & 0x001) printf("udma0 ");
-        if (id->dma_ultra & 0x200) printf("*");
-        if (id->dma_ultra & 0x002) printf("udma1 ");
-        if (id->dma_ultra & 0x400) printf("*");
-        if (id->dma_ultra & 0x004) printf("udma2 ");
+        print_flags(&ultra_modes1, id->dma_ultra);
 #ifdef __NEW_HD_DRIVE_ID
         if (id->hw_config & 0x2000) {
@@ -1203 +1277 @@
         if (id->word93 & 0x2000) {
 #endif /* __NEW_HD_DRIVE_ID */
-            if (id->dma_ultra & 0x0800) printf("*");
-            if (id->dma_ultra & 0x0008) printf("udma3 ");
-            if (id->dma_ultra & 0x1000) printf("*");
-            if (id->dma_ultra & 0x0010) printf("udma4 ");
-            if (id->dma_ultra & 0x2000) printf("*");
-            if (id->dma_ultra & 0x0020) printf("udma5 ");
-            if (id->dma_ultra & 0x4000) printf("*");
-            if (id->dma_ultra & 0x0040) printf("udma6 ");
-            if (id->dma_ultra & 0x8000) printf("*");
-            if (id->dma_ultra & 0x0080) printf("udma7 ");
+            static const masks_labels_t ultra_modes2 = {
+                .masks = { 0x0800, 0x0008, 0x1000, 0x0010,
+                    0x2000, 0x0020, 0x4000, 0x0040,
+                    0x8000, 0x0080 },
+                .labels = "*\0""udma3 \0""*\0""udma4 \0"
+                    "*\0""udma5 \0""*\0""udma6 \0"
+                    "*\0""udma7 \0"
+            };
+            print_flags(&ultra_modes2, id->dma_ultra);
         }
     }
@@ -1230 +1303 @@
      || (id->major_rev_num && id->minor_rev_num <= 31)
     ) {
-        printf("\n Drive conforms to: %s: ", (id->minor_rev_num <= 31) ? minor_str[id->minor_rev_num] : "Unknown");
-        if (id->major_rev_num != 0x0000 &&  /* NOVAL_0 */
-            id->major_rev_num != 0xFFFF) {  /* NOVAL_1 */
+        printf("\n Drive conforms to: %s: ",
+            (id->minor_rev_num <= 31) ? nth_string(minor_str, id->minor_rev_num) : "unknown");
+        if (id->major_rev_num != 0x0000 /* NOVAL_0 */
+         && id->major_rev_num != 0xFFFF /* NOVAL_1 */
+        ) {
             for (i = 0; i <= 15; i++) {
                 if (id->major_rev_num & (1<<i))
-                        printf(" ATA/ATAPI-%u", i);
+                    printf(" ATA/ATAPI-%u", i);
             }
         }
@@ -1244 +1319 @@
 #endif
 
-static void flush_buffer_cache(int fd)
+static void flush_buffer_cache(/*int fd*/ void)
 {
     fsync(fd);              /* flush buffers */
@@ -1259 +1334 @@
 }
 
-static int seek_to_zero(int fd)
-{
-    if (lseek(fd, (off_t) 0, SEEK_SET))
-        return 1;
-    return 0;
-}
-
-static int read_big_block(int fd, char *buf)
+static void seek_to_zero(/*int fd*/ void)
+{
+    xlseek(fd, (off_t) 0, SEEK_SET);
+}
+
+static void read_big_block(/*int fd,*/ char *buf)
 {
     int i;
 
-    i = read(fd, buf, TIMING_BUF_BYTES);
-    if (i != TIMING_BUF_BYTES) {
-        bb_error_msg("read(%d bytes) failed (rc=%d)", TIMING_BUF_BYTES, i);
-        return 1;
-    }
+    xread(fd, buf, TIMING_BUF_BYTES);
     /* access all sectors of buf to ensure the read fully completed */
     for (i = 0; i < TIMING_BUF_BYTES; i += 512)
         buf[i] &= 1;
-    return 0;
-}
-
-static int do_blkgetsize(int fd, unsigned long long *blksize64)
-{
-    int rc;
-    unsigned blksize32 = 0;
-
-    if (0 == ioctl(fd, BLKGETSIZE64, blksize64)) {  // returns bytes
-        *blksize64 /= 512;
-        return 0;
-    }
-    rc = ioctl_or_warn(fd, BLKGETSIZE, &blksize32); // returns sectors
-    *blksize64 = blksize32;
-    return rc;
-}
-
-static void print_timing(unsigned t, double e)
-{
-    if (t >= e)  /* more than 1MB/s */
-        printf("%4d MB in %.2f seconds = %.2f %cB/sec\n", t, e, t / e, 'M');
-    else
-        printf("%4d MB in %.2f seconds = %.2f %cB/sec\n", t, e, t / e * 1024, 'k');
-}
-
-static void do_time(int flag, int fd)
-/* flag = 0 time_cache, 1 time_device */
-{
-    static const struct itimerval thousand = {{1000, 0}, {1000, 0}};
-
-    struct itimerval itv;
+}
+
+static unsigned dev_size_mb(/*int fd*/ void)
+{
+    union {
+        unsigned long long blksize64;
+        unsigned blksize32;
+    } u;
+
+    if (0 == ioctl(fd, BLKGETSIZE64, &u.blksize64)) { // bytes
+        u.blksize64 /= (1024 * 1024);
+    } else {
+        xioctl(fd, BLKGETSIZE, &u.blksize32); // sectors
+        u.blksize64 = u.blksize32 / (2 * 1024);
+    }
+    if (u.blksize64 > UINT_MAX)
+        return UINT_MAX;
+    return u.blksize64;
+}
+
+static void print_timing(unsigned m, unsigned elapsed_us)
+{
+    unsigned sec = elapsed_us / 1000000;
+    unsigned hs = (elapsed_us % 1000000) / 10000;
+
+    printf("%5u MB in %u.%02u seconds = %u kB/s\n",
+        m, sec, hs,
+        /* "| 1" prevents div-by-0 */
+        (unsigned) ((unsigned long long)m * (1024 * 1000000) / (elapsed_us | 1))
+        // ~= (m * 1024) / (elapsed_us / 1000000)
+        // = kb / elapsed_sec
+    );
+}
+
+static void do_time(int cache /*,int fd*/)
+/* cache=1: time cache: repeatedly read N MB at offset 0
+ * cache=0: time device: linear read, starting at offset 0
+ */
+{
+    unsigned max_iterations, iterations;
+    unsigned start; /* doesn't need to be long long */
     unsigned elapsed, elapsed2;
-    unsigned max_iterations, total_MB, iterations;
-    unsigned long long blksize;
-    RESERVE_CONFIG_BUFFER(buf, TIMING_BUF_BYTES);
-
-    if (mlock(buf, TIMING_BUF_BYTES)) {
-        bb_perror_msg("mlock");
-        goto quit2;
-    }
-
-    max_iterations = 1024;
-    if (0 == do_blkgetsize(fd, &blksize)) {
-        max_iterations = blksize / (2 * 1024) / TIMING_BUF_MB;
-    }
-
-    /* Clear out the device request queues & give them time to complete */
+    unsigned total_MB;
+    char *buf = xmalloc(TIMING_BUF_BYTES);
+
+    if (mlock(buf, TIMING_BUF_BYTES))
+        bb_perror_msg_and_die("mlock");
+
+    /* Clear out the device request queues & give them time to complete.
+     * NB: *small* delay. User is expected to have a clue and to not run
+     * heavy io in parallel with measurements. */
     sync();
-    sleep(2);
-    if (flag == 0) { /* Time cache */
-        if (seek_to_zero(fd))
-            goto quit;
-        if (read_big_block(fd, buf))
-            goto quit;
-        printf(" Timing buffer-cache reads:  ");
+    sleep(1);
+    if (cache) { /* Time cache */
+        seek_to_zero();
+        read_big_block(buf);
+        printf("Timing buffer-cache reads: ");
     } else { /* Time device */
-        printf(" Timing buffered disk reads: ");
-    }
-    fflush(stdout);
+        printf("Timing buffered disk reads:");
+    }
+    fflush_all();
+
+    /* Now do the timing */
     iterations = 0;
-    /*
-     * getitimer() is used rather than gettimeofday() because
-     * it is much more consistent (on my machine, at least).
-     */
-    setitimer(ITIMER_REAL, &thousand, NULL);
-    /* Now do the timing */
+    /* Max time to run (small for cache, avoids getting
+     * huge total_MB which can overlow unsigned type) */
+    elapsed2 = 510000; /* cache */
+    max_iterations = UINT_MAX;
+    if (!cache) {
+        elapsed2 = 3000000; /* not cache */
+        /* Don't want to read past the end! */
+        max_iterations = dev_size_mb() / TIMING_BUF_MB;
+    }
+    start = monotonic_us();
     do {
+        if (cache)
+            seek_to_zero();
+        read_big_block(buf);
+        elapsed = (unsigned)monotonic_us() - start;
         ++iterations;
-        if ((flag == 0) && seek_to_zero(fd))
-            goto quit;
-        if (read_big_block(fd, buf))
-            goto quit;
-        getitimer(ITIMER_REAL, &itv);
-        elapsed = (1000 - itv.it_value.tv_sec) * 1000000
-                - itv.it_value.tv_usec;
-    } while (elapsed < 3000000 && iterations < max_iterations);
+    } while (elapsed < elapsed2 && iterations < max_iterations);
     total_MB = iterations * TIMING_BUF_MB;
-    if (flag == 0) {
-        /* Now remove the lseek() and getitimer() overheads from the elapsed time */
-        setitimer(ITIMER_REAL, &thousand, NULL);
+    //printf(" elapsed:%u iterations:%u ", elapsed, iterations);
+    if (cache) {
+        /* Cache: remove lseek() and monotonic_us() overheads
+         * from elapsed */
+        start = monotonic_us();
         do {
-            if (seek_to_zero(fd))
-                goto quit;
-            getitimer(ITIMER_REAL, &itv);
-            elapsed2 = (1000 - itv.it_value.tv_sec) * 1000000
-                    - itv.it_value.tv_usec;
+            seek_to_zero();
+            elapsed2 = (unsigned)monotonic_us() - start;
         } while (--iterations);
+        //printf(" elapsed2:%u ", elapsed2);
         elapsed -= elapsed2;
-        total_MB *= BUFCACHE_FACTOR;
-        flush_buffer_cache(fd);
-    }
-    print_timing(total_MB, elapsed / 1000000.0);
- quit:
+        total_MB *= 2; // BUFCACHE_FACTOR (why?)
+        flush_buffer_cache();
+    }
+    print_timing(total_MB, elapsed);
     munlock(buf, TIMING_BUF_BYTES);
- quit2:
-    RELEASE_CONFIG_BUFFER(buf);
+    free(buf);
 }
 
@@ -1391 +1463 @@
 
 #ifdef HDIO_DRIVE_CMD
-static void interpret_standby(unsigned standby)
-{
-    unsigned t;
-
+static void interpret_standby(uint8_t standby)
+{
     printf(" (");
-    if (standby == 0)
+    if (standby == 0) {
         printf("off");
-    else if (standby == 252)
-        printf("21 minutes");
-    else if (standby == 253)
+    } else if (standby <= 240 || standby == 252 || standby == 255) {
+        /* standby is in 5 sec units */
+        unsigned t = standby * 5;
+        printf("%u minutes %u seconds", t / 60, t % 60);
+    } else if (standby <= 251) {
+        unsigned t = (standby - 240); /* t is in 30 min units */;
+        printf("%u.%c hours", t / 2, (t & 1) ? '5' : '0');
+    }
+    if (standby == 253)
         printf("vendor-specific");
-    else if (standby == 254)
-        printf("Reserved");
-    else if (standby == 255)
-        printf("21 minutes + 15 seconds");
-    else if (standby <= 240) {
-        t = standby * 5;
-        printf("%u minutes + %u seconds", t / 60, t % 60);
-    } else if (standby <= 251) {
-        t = (standby - 240) * 30;
-        printf("%u hours + %u minutes", t / 60, t % 60);
-    } else
-        printf("illegal value");
+    if (standby == 254)
+        printf("reserved");
     printf(")\n");
 }
@@ -1433 +1499 @@
 static int translate_xfermode(const char *name)
 {
-    int val, i;
+    int val;
+    unsigned i;
 
     for (i = 0; i < ARRAY_SIZE(xfermode_val); i++) {
@@ -1463 +1530 @@
         printf("UltraDMA mode%u", xfermode - 64);
     else
-        printf("Unknown");
+        printf("unknown");
     printf(")\n");
 }
@@ -1476 +1543 @@
 static void process_dev(char *devname)
 {
-    int fd;
+    /*int fd;*/
     long parm, multcount;
 #ifndef HDIO_DRIVE_CMD
@@ -1486 +1553 @@
     const char *fmt = " %s\t= %2ld";
 
-    fd = xopen(devname, O_RDONLY|O_NONBLOCK);
+    /*fd = xopen_nonblocking(devname);*/
+    xmove_fd(xopen_nonblocking(devname), fd);
     printf("\n%s:\n", devname);
 
-    if (set_readahead) {
-        print_flag(get_readahead, "fs readahead", Xreadahead);
+    if (getset_readahead == IS_SET) {
+        print_flag(getset_readahead, "fs readahead", Xreadahead);
         ioctl_or_warn(fd, BLKRASET, (int *)Xreadahead);
     }
@@ -1500 +1568 @@
 #endif
 #if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
-    if (scan_hwif) {
+    if (scan_hwif == IS_SET) {
         printf(" attempting to scan hwif (0x%lx, 0x%lx, %lu)\n", hwif_data, hwif_ctrl, hwif_irq);
         args[0] = hwif_data;
@@ -1524 +1592 @@
         ioctl_or_warn(fd, HDIO_SET_PIO_MODE, (int *)(unsigned long)piomode);
     }
-    if (set_io32bit) {
-        print_flag(get_io32bit, "32-bit IO_support flag", io32bit);
+    if (getset_io32bit == IS_SET) {
+        print_flag(getset_io32bit, "32-bit IO_support flag", io32bit);
         ioctl_or_warn(fd, HDIO_SET_32BIT, (int *)io32bit);
     }
-    if (set_mult) {
-        print_flag(get_mult, "multcount", mult);
+    if (getset_mult == IS_SET) {
+        print_flag(getset_mult, "multcount", mult);
 #ifdef HDIO_DRIVE_CMD
         ioctl_or_warn(fd, HDIO_SET_MULTCOUNT, (void *)mult);
@@ -1536 +1604 @@
 #endif
     }
-    if (set_readonly) {
-        print_flag_on_off(get_readonly, "readonly", readonly);
+    if (getset_readonly == IS_SET) {
+        print_flag_on_off(getset_readonly, "readonly", readonly);
         ioctl_or_warn(fd, BLKROSET, &readonly);
     }
-    if (set_unmask) {
-        print_flag_on_off(get_unmask, "unmaskirq", unmask);
+    if (getset_unmask == IS_SET) {
+        print_flag_on_off(getset_unmask, "unmaskirq", unmask);
         ioctl_or_warn(fd, HDIO_SET_UNMASKINTR, (int *)unmask);
     }
 #if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
-    if (set_dma) {
-        print_flag_on_off(get_dma, "using_dma", dma);
+    if (getset_dma == IS_SET) {
+        print_flag_on_off(getset_dma, "using_dma", dma);
         ioctl_or_warn(fd, HDIO_SET_DMA, (int *)dma);
     }
 #endif /* FEATURE_HDPARM_HDIO_GETSET_DMA */
-    if (set_dma_q) {
-        print_flag_on_off(get_dma_q, "DMA queue_depth", dma_q);
+#ifdef HDIO_SET_QDMA
+    if (getset_dma_q == IS_SET) {
+        print_flag_on_off(getset_dma_q, "DMA queue_depth", dma_q);
         ioctl_or_warn(fd, HDIO_SET_QDMA, (int *)dma_q);
     }
-    if (set_nowerr) {
-        print_flag_on_off(get_nowerr, "nowerr", nowerr);
+#endif
+    if (getset_nowerr == IS_SET) {
+        print_flag_on_off(getset_nowerr, "nowerr", nowerr);
         ioctl_or_warn(fd, HDIO_SET_NOWERR, (int *)nowerr);
     }
-    if (set_keep) {
-        print_flag_on_off(get_keep, "keep_settings", keep);
+    if (getset_keep == IS_SET) {
+        print_flag_on_off(getset_keep, "keep_settings", keep);
         ioctl_or_warn(fd, HDIO_SET_KEEPSETTINGS, (int *)keep);
     }
 #ifdef HDIO_DRIVE_CMD
-    if (set_doorlock) {
+    if (getset_doorlock == IS_SET) {
         args[0] = doorlock ? WIN_DOORLOCK : WIN_DOORUNLOCK;
         args[2] = 0;
-        print_flag_on_off(get_doorlock, "drive doorlock", doorlock);
+        print_flag_on_off(getset_doorlock, "drive doorlock", doorlock);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[0] = WIN_SETFEATURES;
     }
-    if (set_dkeep) {
+    if (getset_dkeep == IS_SET) {
         /* lock/unlock the drive's "feature" settings */
-        print_flag_on_off(get_dkeep, "drive keep features", dkeep);
+        print_flag_on_off(getset_dkeep, "drive keep features", dkeep);
         args[2] = dkeep ? 0x66 : 0xcc;
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
     }
-    if (set_defects) {
+    if (getset_defects == IS_SET) {
         args[2] = defects ? 0x04 : 0x84;
-        print_flag(get_defects, "drive defect-mgmt", defects);
+        print_flag(getset_defects, "drive defect-mgmt", defects);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
     }
-    if (set_prefetch) {
+    if (getset_prefetch == IS_SET) {
         args[1] = prefetch;
         args[2] = 0xab;
-        print_flag(get_prefetch, "drive prefetch", prefetch);
+        print_flag(getset_prefetch, "drive prefetch", prefetch);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[1] = 0;
@@ -1591 +1661 @@
         args[1] = xfermode_requested;
         args[2] = 3;
-        if (get_xfermode) {
-            print_flag(1, "xfermode", xfermode_requested);
-            interpret_xfermode(xfermode_requested);
-        }
+        print_flag(1, "xfermode", xfermode_requested);
+        interpret_xfermode(xfermode_requested);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[1] = 0;
     }
-    if (set_lookahead) {
+    if (getset_lookahead == IS_SET) {
         args[2] = lookahead ? 0xaa : 0x55;
-        print_flag_on_off(get_lookahead, "drive read-lookahead", lookahead);
+        print_flag_on_off(getset_lookahead, "drive read-lookahead", lookahead);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
     }
-    if (set_apmmode) {
-        args[2] = (apmmode == 255) ? 0x85 /* disable */ : 0x05 /* set */; /* feature register */
+    if (getset_apmmode == IS_SET) {
+        /* feature register */
+        args[2] = (apmmode == 255) ? 0x85 /* disable */ : 0x05 /* set */;
         args[1] = apmmode; /* sector count register 1-255 */
-        if (get_apmmode)
-            printf(" setting APM level to %s 0x%02lX (%ld)\n", (apmmode == 255) ? "disabled" : "", apmmode, apmmode);
+        printf(" setting APM level to %s 0x%02lX (%ld)\n",
+            (apmmode == 255) ? "disabled" : "",
+            apmmode, apmmode);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[1] = 0;
     }
-    if (set_wcache) {
+    if (getset_wcache == IS_SET) {
 #ifdef DO_FLUSHCACHE
 #ifndef WIN_FLUSHCACHE
 #define WIN_FLUSHCACHE 0xe7
 #endif
-        static unsigned char flushcache[4] = { WIN_FLUSHCACHE, 0, 0, 0 };
 #endif /* DO_FLUSHCACHE */
         args[2] = wcache ? 0x02 : 0x82;
-        print_flag_on_off(get_wcache, "drive write-caching", wcache);
+        print_flag_on_off(getset_wcache, "drive write-caching", wcache);
 #ifdef DO_FLUSHCACHE
         if (!wcache)
@@ -1642 +1711 @@
 #define WIN_STANDBYNOW2 0x94
 #endif
-        if (get_standbynow) printf(" issuing standby command\n");
+        printf(" issuing standby command\n");
         args[0] = WIN_STANDBYNOW1;
-        ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_STANDBYNOW2);
+        ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_STANDBYNOW2);
     }
     if (set_sleepnow) {
@@ -1653 +1722 @@
 #define WIN_SLEEPNOW2 0x99
 #endif
-        if (get_sleepnow) printf(" issuing sleep command\n");
+        printf(" issuing sleep command\n");
         args[0] = WIN_SLEEPNOW1;
-        ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_SLEEPNOW2);
+        ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_SLEEPNOW2);
     }
     if (set_seagate) {
         args[0] = 0xfb;
-        if (get_seagate) printf(" disabling Seagate auto powersaving mode\n");
+        printf(" disabling Seagate auto powersaving mode\n");
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
     }
-    if (set_standby) {
+    if (getset_standby == IS_SET) {
         args[0] = WIN_SETIDLE1;
         args[1] = standby_requested;
-        if (get_standby) {
-            print_flag(1, "standby", standby_requested);
-            interpret_standby(standby_requested);
-        }
+        print_flag(1, "standby", standby_requested);
+        interpret_standby(standby_requested);
         ioctl_or_warn(fd, HDIO_DRIVE_CMD, &args);
         args[1] = 0;
@@ -1675 +1742 @@
     if (force_operation) {
         char buf[512];
-        flush_buffer_cache(fd);
+        flush_buffer_cache();
         if (-1 == read(fd, buf, sizeof(buf)))
-            bb_perror_msg("read(%d bytes) failed (rc=%d)", sizeof(buf), -1);
-    }
-#endif  /* HDIO_DRIVE_CMD */
-
-    if (get_mult || get_identity) {
+            bb_perror_msg("read of 512 bytes failed");
+    }
+#endif  /* HDIO_DRIVE_CMD */
+    if (getset_mult || get_identity) {
         multcount = -1;
         if (ioctl(fd, HDIO_GET_MULTCOUNT, &multcount)) {
-            if (get_mult && ENABLE_IOCTL_HEX2STR_ERROR) /* To be coherent with ioctl_or_warn. */
+            /* To be coherent with ioctl_or_warn. */
+            if (getset_mult && ENABLE_IOCTL_HEX2STR_ERROR)
                 bb_perror_msg("HDIO_GET_MULTCOUNT");
             else
                 bb_perror_msg("ioctl %#x failed", HDIO_GET_MULTCOUNT);
-        } else if (get_mult) {
+        } else if (getset_mult) {
             printf(fmt, "multcount", multcount);
             on_off(multcount != 0);
         }
     }
-    if (get_io32bit) {
+    if (getset_io32bit) {
         if (!ioctl_or_warn(fd, HDIO_GET_32BIT, &parm)) {
             printf(" IO_support\t=%3ld (", parm);
@@ -1710 +1777 @@
         }
     }
-    if (get_unmask) {
-        if(!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, (unsigned long *)parm))
+    if (getset_unmask) {
+        if (!ioctl_or_warn(fd, HDIO_GET_UNMASKINTR, &parm))
             print_value_on_off("unmaskirq", parm);
     }
-
-
 #if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
-    if (get_dma) {
+    if (getset_dma) {
         if (!ioctl_or_warn(fd, HDIO_GET_DMA, &parm)) {
             printf(fmt, "using_dma", parm);
@@ -1727 +1792 @@
     }
 #endif
-    if (get_dma_q) {
-        if(!ioctl_or_warn(fd, HDIO_GET_QDMA, (unsigned long *)parm))
+#ifdef HDIO_GET_QDMA
+    if (getset_dma_q) {
+        if (!ioctl_or_warn(fd, HDIO_GET_QDMA, &parm))
             print_value_on_off("queue_depth", parm);
     }
-    if (get_keep) {
-        if(!ioctl_or_warn(fd, HDIO_GET_KEEPSETTINGS, (unsigned long *)parm))
+#endif
+    if (getset_keep) {
+        if (!ioctl_or_warn(fd, HDIO_GET_KEEPSETTINGS, &parm))
             print_value_on_off("keepsettings", parm);
     }
-
-    if (get_nowerr) {
-        if(!ioctl_or_warn(fd, HDIO_GET_NOWERR, (unsigned long *)parm))
+    if (getset_nowerr) {
+        if (!ioctl_or_warn(fd, HDIO_GET_NOWERR, &parm))
             print_value_on_off("nowerr", parm);
     }
-    if (get_readonly) {
-        if(!ioctl_or_warn(fd, BLKROGET, (unsigned long *)parm))
+    if (getset_readonly) {
+        if (!ioctl_or_warn(fd, BLKROGET, &parm))
             print_value_on_off("readonly", parm);
     }
-    if (get_readahead) {
-        if(!ioctl_or_warn(fd, BLKRAGET, (unsigned long *)parm))
+    if (getset_readahead) {
+        if (!ioctl_or_warn(fd, BLKRAGET, &parm))
             print_value_on_off("readahead", parm);
     }
@@ -1754 +1820 @@
             if (!ioctl_or_warn(fd, HDIO_GETGEO, &g))
                 printf(" geometry\t= %u/%u/%u, sectors = %ld, start = %ld\n",
-                        g.cylinders, g.heads, g.sectors, parm, g.start);
+                    g.cylinders, g.heads, g.sectors, parm, g.start);
         }
     }
@@ -1768 +1834 @@
 
         args[0] = WIN_CHECKPOWERMODE1;
-        if (ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2)) {
+        if (ioctl_alt_or_warn(HDIO_DRIVE_CMD, args, WIN_CHECKPOWERMODE2)) {
             if (errno != EIO || args[0] != 0 || args[1] != 0)
                 state = "unknown";
@@ -1817 +1883 @@
         args1[0] = WIN_IDENTIFY;
         args1[3] = 1;
-        if (!ioctl_alt_or_warn(fd, HDIO_DRIVE_CMD, args1, WIN_PIDENTIFY))
+        if (!ioctl_alt_or_warn(HDIO_DRIVE_CMD, args1, WIN_PIDENTIFY))
             identify((void *)(args1 + 4));
     }
 #endif
 #if ENABLE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
-    if (set_busstate) {
-        if (get_busstate) {
-            print_flag(1, "bus state", busstate);
-            bus_state_value(busstate);
-        }
+    if (getset_busstate == IS_SET) {
+        print_flag(1, "bus state", busstate);
+        bus_state_value(busstate);
         ioctl_or_warn(fd, HDIO_SET_BUSSTATE, (int *)(unsigned long)busstate);
     }
-    if (get_busstate) {
+    if (getset_busstate) {
         if (!ioctl_or_warn(fd, HDIO_GET_BUSSTATE, &parm)) {
             printf(fmt, "bus state", parm);
@@ -1840 +1904 @@
 
     if (do_ctimings)
-        do_time(0, fd); /* time cache */
+        do_time(1 /*,fd*/); /* time cache */
     if (do_timings)
-        do_time(1, fd); /* time device */
+        do_time(0 /*,fd*/); /* time device */
     if (do_flush)
-        flush_buffer_cache(fd);
+        flush_buffer_cache();
     close(fd);
 }
@@ -1858 +1922 @@
 }
 
+static void identify_from_stdin(void) NORETURN;
 static void identify_from_stdin(void)
 {
@@ -1865 +1930 @@
     int i;
 
-    xread(0, buf, 1280);
+    xread(STDIN_FILENO, buf, 1280);
 
     // Convert the newline-separated hex data into an identify block.
@@ -1879 +1944 @@
     identify(sbuf);
 }
+#else
+void identify_from_stdin(void);
 #endif
 
 /* busybox specific stuff */
-static void parse_opts(smallint *get, smallint *set, unsigned long *value, int min, int max)
-{
-    if (get) {
-        *get = 1;
-    }
+static int parse_opts(unsigned long *value, int min, int max)
+{
     if (optarg) {
-        *set = 1;
         *value = xatol_range(optarg, min, max);
-    }
+        return IS_SET;
+    }
+    return IS_GET;
+}
+static int parse_opts_0_max(unsigned long *value, int max)
+{
+    return parse_opts(value, 0, max);
+}
+static int parse_opts_0_1(unsigned long *value)
+{
+    return parse_opts(value, 0, 1);
+}
+static int parse_opts_0_INTMAX(unsigned long *value)
+{
+    return parse_opts(value, 0, INT_MAX);
 }
 
@@ -1896 +1973 @@
 {
     if (flag) {
-        *get = 1;
+        *get = IS_GET;
         if (optarg) {
             *value = translate_xfermode(optarg);
@@ -1906 +1983 @@
 /*------- getopt short options --------*/
 static const char hdparm_options[] ALIGN1 =
-    "gfu::n::p:r::m::c::k::a::B:tTh"
-    USE_FEATURE_HDPARM_GET_IDENTITY("iI")
-    USE_FEATURE_HDPARM_HDIO_GETSET_DMA("d::")
+    "gfu::n::p:r::m::c::k::a::B:tT"
+    IF_FEATURE_HDPARM_GET_IDENTITY("iI")
+    IF_FEATURE_HDPARM_HDIO_GETSET_DMA("d::")
 #ifdef HDIO_DRIVE_CMD
     "S:D:P:X:K:A:L:W:CyYzZ"
 #endif
-    USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF("U:")
+    IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF("U:")
 #ifdef HDIO_GET_QDMA
 #ifdef HDIO_SET_QDMA
@@ -1920 +1997 @@
 #endif
 #endif
-    USE_FEATURE_HDPARM_HDIO_DRIVE_RESET("w")
-    USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF("x::b:")
-    USE_FEATURE_HDPARM_HDIO_SCAN_HWIF("R:");
+    IF_FEATURE_HDPARM_HDIO_DRIVE_RESET("w")
+    IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF("x::b:")
+    IF_FEATURE_HDPARM_HDIO_SCAN_HWIF("R:");
 /*-------------------------------------*/
 
 /* our main() routine: */
-int hdparm_main(int argc, char **argv);
+int hdparm_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int hdparm_main(int argc, char **argv)
 {
@@ -1934 +2011 @@
     while ((c = getopt(argc, argv, hdparm_options)) >= 0) {
         flagcount++;
-        if (c == 'h') bb_show_usage(); /* EXIT */
-        USE_FEATURE_HDPARM_GET_IDENTITY(get_IDentity |= (c == 'I'));
-        USE_FEATURE_HDPARM_GET_IDENTITY(get_identity |= (c == 'i'));
+        IF_FEATURE_HDPARM_GET_IDENTITY(get_IDentity |= (c == 'I'));
+        IF_FEATURE_HDPARM_GET_IDENTITY(get_identity |= (c == 'i'));
         get_geom |= (c == 'g');
         do_flush |= (c == 'f');
-        if (c == 'u') parse_opts(&get_unmask, &set_unmask, &unmask, 0, 1);
-        USE_FEATURE_HDPARM_HDIO_GETSET_DMA(if (c == 'd') parse_opts(&get_dma, &set_dma, &dma, 0, 9));
-        if (c == 'n') parse_opts(&get_nowerr, &set_nowerr, &nowerr, 0, 1);
+        if (c == 'u') getset_unmask    = parse_opts_0_1(&unmask);
+    IF_FEATURE_HDPARM_HDIO_GETSET_DMA(
+        if (c == 'd') getset_dma       = parse_opts_0_max(&dma, 9);
+    )
+        if (c == 'n') getset_nowerr    = parse_opts_0_1(&nowerr);
         parse_xfermode((c == 'p'), &noisy_piomode, &set_piomode, &piomode);
-        if (c == 'r') parse_opts(&get_readonly, &set_readonly, &readonly, 0, 1);
-        if (c == 'm') parse_opts(&get_mult, &set_mult, &mult, 0, INT_MAX /*32*/);
-        if (c == 'c') parse_opts(&get_io32bit, &set_io32bit, &io32bit, 0, INT_MAX /*8*/);
-        if (c == 'k') parse_opts(&get_keep, &set_keep, &keep, 0, 1);
-        if (c == 'a') parse_opts(&get_readahead, &set_readahead, &Xreadahead, 0, INT_MAX);
-        if (c == 'B') parse_opts(&get_apmmode, &set_apmmode, &apmmode, 1, 255);
+        if (c == 'r') getset_readonly  = parse_opts_0_1(&readonly);
+        if (c == 'm') getset_mult      = parse_opts_0_INTMAX(&mult /*32*/);
+        if (c == 'c') getset_io32bit   = parse_opts_0_INTMAX(&io32bit /*8*/);
+        if (c == 'k') getset_keep      = parse_opts_0_1(&keep);
+        if (c == 'a') getset_readahead = parse_opts_0_INTMAX(&Xreadahead);
+        if (c == 'B') getset_apmmode   = parse_opts(&apmmode, 1, 255);
         do_flush |= do_timings |= (c == 't');
         do_flush |= do_ctimings |= (c == 'T');
 #ifdef HDIO_DRIVE_CMD
-        if (c == 'S') parse_opts(&get_standby, &set_standby, &standby_requested, 0, INT_MAX);
-        if (c == 'D') parse_opts(&get_defects, &set_defects, &defects, 0, INT_MAX);
-        if (c == 'P') parse_opts(&get_prefetch, &set_prefetch, &prefetch, 0, INT_MAX);
+        if (c == 'S') getset_standby  = parse_opts_0_max(&standby_requested, 255);
+        if (c == 'D') getset_defects  = parse_opts_0_INTMAX(&defects);
+        if (c == 'P') getset_prefetch = parse_opts_0_INTMAX(&prefetch);
         parse_xfermode((c == 'X'), &get_xfermode, &set_xfermode, &xfermode_requested);
-        if (c == 'K') parse_opts(&get_dkeep, &set_dkeep, &prefetch, 0, 1);
-        if (c == 'A') parse_opts(&get_lookahead, &set_lookahead, &lookahead, 0, 1);
-        if (c == 'L') parse_opts(&get_doorlock, &set_doorlock, &doorlock, 0, 1);
-        if (c == 'W') parse_opts(&get_wcache, &set_wcache, &wcache, 0, 1);
+        if (c == 'K') getset_dkeep     = parse_opts_0_1(&prefetch);
+        if (c == 'A') getset_lookahead = parse_opts_0_1(&lookahead);
+        if (c == 'L') getset_doorlock  = parse_opts_0_1(&doorlock);
+        if (c == 'W') getset_wcache    = parse_opts_0_1(&wcache);
         get_powermode |= (c == 'C');
-        get_standbynow = set_standbynow |= (c == 'y');
-        get_sleepnow = set_sleepnow |= (c == 'Y');
+        set_standbynow |= (c == 'y');
+        set_sleepnow |= (c == 'Y');
         reread_partn |= (c == 'z');
-        get_seagate = set_seagate |= (c == 'Z');
-#endif
-        USE_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(if (c == 'U') parse_opts(NULL, &unregister_hwif, &hwif, 0, INT_MAX));
+        set_seagate |= (c == 'Z');
+#endif
+        IF_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF(if (c == 'U') unregister_hwif = parse_opts_0_INTMAX(&hwif));
 #ifdef HDIO_GET_QDMA
         if (c == 'Q') {
-#ifdef HDIO_SET_QDMA
-            parse_opts(&get_dma_q, &set_dma_q, &dma_q, 0, INT_MAX);
-#else
-            parse_opts(&get_dma_q, NULL, NULL, 0, 0);
-#endif
-        }
-#endif
-        USE_FEATURE_HDPARM_HDIO_DRIVE_RESET(perform_reset = (c == 'r'));
-        USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'x') parse_opts(NULL, &perform_tristate, &tristate, 0, 1));
-        USE_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'b') parse_opts(&get_busstate, &set_busstate, &busstate, 0, 2));
+            getset_dma_q = parse_opts_0_INTMAX(&dma_q);
+        }
+#endif
+        IF_FEATURE_HDPARM_HDIO_DRIVE_RESET(perform_reset = (c == 'r'));
+        IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'x') perform_tristate = parse_opts_0_1(&tristate));
+        IF_FEATURE_HDPARM_HDIO_TRISTATE_HWIF(if (c == 'b') getset_busstate = parse_opts_0_max(&busstate, 2));
 #if ENABLE_FEATURE_HDPARM_HDIO_SCAN_HWIF
         if (c == 'R') {
-            parse_opts(NULL, &scan_hwif, &hwif_data, 0, INT_MAX);
-            hwif_ctrl = xatoi_u((argv[optind]) ? argv[optind] : "");
-            hwif_irq  = xatoi_u((argv[optind+1]) ? argv[optind+1] : "");
+            scan_hwif = parse_opts_0_INTMAX(&hwif_data);
+            hwif_ctrl = xatoi_positive((argv[optind]) ? argv[optind] : "");
+            hwif_irq  = xatoi_positive((argv[optind+1]) ? argv[optind+1] : "");
             /* Move past the 2 additional arguments */
             argv += 2;
@@ -1992 +2066 @@
     /* When no flags are given (flagcount = 0), -acdgkmnru is assumed. */
     if (!flagcount) {
-        get_mult = get_io32bit = get_unmask = get_keep = get_readonly = get_readahead = get_geom = 1;
-        USE_FEATURE_HDPARM_HDIO_GETSET_DMA(get_dma = 1);
+        getset_mult = getset_io32bit = getset_unmask = getset_keep = getset_readonly = getset_readahead = get_geom = IS_GET;
+        IF_FEATURE_HDPARM_HDIO_GETSET_DMA(getset_dma = IS_GET);
     }
     argv += optind;
@@ -2000 +2074 @@
         if (ENABLE_FEATURE_HDPARM_GET_IDENTITY && !isatty(STDIN_FILENO))
             identify_from_stdin(); /* EXIT */
-        else bb_show_usage();
+        bb_show_usage();
     }
 

branches/2.2.9/mindi-busybox/miscutils/last.c

@@ -5 +5 @@
  * Copyright (C) 2003-2004 by Erik Andersen <andersen@codepoet.org>
  *
- * Licensed under the GPL version 2, see the file LICENSE in this tarball.
+ * Licensed under GPLv2, see file LICENSE in this source tree.
  */
 
@@ -11 +11 @@
 #include <utmp.h>
 
+/* NB: ut_name and ut_user are the same field, use only one name (ut_user)
+ * to reduce confusion */
+
 #ifndef SHUTDOWN_TIME
 #  define SHUTDOWN_TIME 254
 #endif
 
-/* Grr... utmp char[] members  do not have to be nul-terminated.
+/* Grr... utmp char[] members do not have to be nul-terminated.
  * Do what we can while still keeping this reasonably small.
  * Note: We are assuming the ut_id[] size is fixed at 4. */
@@ -27 +30 @@
 #endif
 
-int last_main(int argc, char **argv);
-int last_main(int argc, char **argv)
+#if EMPTY != 0 || RUN_LVL != 1 || BOOT_TIME != 2 || NEW_TIME != 3 || \
+    OLD_TIME != 4
+#error Values for the ut_type field of struct utmp changed
+#endif
+
+int last_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int last_main(int argc UNUSED_PARAM, char **argv UNUSED_PARAM)
 {
     struct utmp ut;
     int n, file = STDIN_FILENO;
     time_t t_tmp;
+    off_t pos;
+    static const char _ut_usr[] ALIGN1 =
+            "runlevel\0" "reboot\0" "shutdown\0";
+    static const char _ut_lin[] ALIGN1 =
+            "~\0" "{\0" "|\0" /* "LOGIN\0" "date\0" */;
+    enum {
+        TYPE_RUN_LVL = RUN_LVL,         /* 1 */
+        TYPE_BOOT_TIME = BOOT_TIME,     /* 2 */
+        TYPE_SHUTDOWN_TIME = SHUTDOWN_TIME
+    };
+    enum {
+        _TILDE = EMPTY, /* 0 */
+        TYPE_NEW_TIME,  /* NEW_TIME, 3 */
+        TYPE_OLD_TIME   /* OLD_TIME, 4 */
+    };
 
-    if (argc > 1) {
+    if (argv[1]) {
         bb_show_usage();
     }
     file = xopen(bb_path_wtmp_file, O_RDONLY);
 
-    printf("%-10s %-14s %-18s %-12.12s %s\n", "USER", "TTY", "HOST", "LOGIN", "TIME");
-    while ((n = safe_read(file, (void*)&ut, sizeof(struct utmp))) != 0) {
-
-        if (n != sizeof(struct utmp)) {
+    printf("%-10s %-14s %-18s %-12.12s %s\n",
+           "USER", "TTY", "HOST", "LOGIN", "TIME");
+    /* yikes. We reverse over the file and that is a not too elegant way */
+    pos = xlseek(file, 0, SEEK_END);
+    pos = lseek(file, pos - sizeof(ut), SEEK_SET);
+    while ((n = full_read(file, &ut, sizeof(ut))) > 0) {
+        if (n != sizeof(ut)) {
             bb_perror_msg_and_die("short read");
         }
-
-        if (ut.ut_line[0] == '~') {
+        n = index_in_strings(_ut_lin, ut.ut_line);
+        if (n == _TILDE) { /* '~' */
+#if 1
+/* do we really need to be cautious here? */
+            n = index_in_strings(_ut_usr, ut.ut_user);
+            if (++n > 0)
+                ut.ut_type = n != 3 ? n : SHUTDOWN_TIME;
+#else
             if (strncmp(ut.ut_user, "shutdown", 8) == 0)
                 ut.ut_type = SHUTDOWN_TIME;
             else if (strncmp(ut.ut_user, "reboot", 6) == 0)
                 ut.ut_type = BOOT_TIME;
-            else if (strncmp(ut.ut_user, "runlevel", 7) == 0)
+            else if (strncmp(ut.ut_user, "runlevel", 8) == 0)
                 ut.ut_type = RUN_LVL;
+#endif
         } else {
-            if (!ut.ut_name[0] || strcmp(ut.ut_name, "LOGIN") == 0 ||
-                    ut.ut_name[0] == 0)
-            {
+            if (ut.ut_user[0] == '\0' || strcmp(ut.ut_user, "LOGIN") == 0) {
                 /* Don't bother.  This means we can't find how long
                  * someone was logged in for.  Oh well. */
-                continue;
+                goto next;
             }
-            if (ut.ut_type != DEAD_PROCESS &&
-                    ut.ut_name[0] && ut.ut_line[0])
-            {
+            if (ut.ut_type != DEAD_PROCESS
+             && ut.ut_user[0]
+             && ut.ut_line[0]
+            ) {
                 ut.ut_type = USER_PROCESS;
             }
-            if (strcmp(ut.ut_name, "date") == 0) {
-                if (ut.ut_line[0] == '|') ut.ut_type = OLD_TIME;
-                if (ut.ut_line[0] == '{') ut.ut_type = NEW_TIME;
+            if (strcmp(ut.ut_user, "date") == 0) {
+                if (n == TYPE_OLD_TIME) { /* '|' */
+                    ut.ut_type = OLD_TIME;
+                }
+                if (n == TYPE_NEW_TIME) { /* '{' */
+                    ut.ut_type = NEW_TIME;
+                }
             }
         }
 
-        if (ut.ut_type!=USER_PROCESS) {
+        if (ut.ut_type != USER_PROCESS) {
             switch (ut.ut_type) {
                 case OLD_TIME:
@@ -78 +114 @@
                 case RUN_LVL:
                 case SHUTDOWN_TIME:
-                    continue;
+                    goto next;
                 case BOOT_TIME:
                     strcpy(ut.ut_line, "system boot");
-                    break;
             }
         }
+        /* manpages say ut_tv.tv_sec *is* time_t,
+         * but some systems have it wrong */
         t_tmp = (time_t)ut.ut_tv.tv_sec;
-        printf("%-10s %-14s %-18s %-12.12s\n", ut.ut_user, ut.ut_line, ut.ut_host,
-                ctime(&t_tmp) + 4);
+        printf("%-10s %-14s %-18s %-12.12s\n",
+               ut.ut_user, ut.ut_line, ut.ut_host, ctime(&t_tmp) + 4);
+ next:
+        pos -= sizeof(ut);
+        if (pos <= 0)
+            break; /* done. */
+        xlseek(file, pos, SEEK_SET);
     }
 

branches/2.2.9/mindi-busybox/miscutils/less.c

@@ -5 +5 @@
  * Copyright (C) 2005 by Rob Sullivan <cogito.ergo.cogito@gmail.com>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -22 +22 @@
  */
 
-#include <sched.h>  /* sched_yield() */
+#include <sched.h>  /* sched_yield() */
 
 #include "libbb.h"
@@ -29 +29 @@
 #endif
 
-/* FIXME: currently doesn't work right */
-#undef ENABLE_FEATURE_LESS_FLAGCS
-#define ENABLE_FEATURE_LESS_FLAGCS 0
-
+
+#define ESC "\033"
 /* The escape codes for highlighted and normal text */
-#define HIGHLIGHT "\033[7m"
-#define NORMAL "\033[0m"
-/* The escape code to clear the screen */
-#define CLEAR "\033[H\033[J"
-/* The escape code to clear to end of line */
-#define CLEAR_2_EOL "\033[K"
-
-/* These are the escape sequences corresponding to special keys */
+#define HIGHLIGHT   ESC"[7m"
+#define NORMAL      ESC"[0m"
+/* The escape code to home and clear to the end of screen */
+#define CLEAR       ESC"[H\033[J"
+/* The escape code to clear to the end of line */
+#define CLEAR_2_EOL ESC"[K"
+
 enum {
-    REAL_KEY_UP = 'A',
-    REAL_KEY_DOWN = 'B',
-    REAL_KEY_RIGHT = 'C',
-    REAL_KEY_LEFT = 'D',
-    REAL_PAGE_UP = '5',
-    REAL_PAGE_DOWN = '6',
-    REAL_KEY_HOME = '7', // vt100? linux vt? or what?
-    REAL_KEY_END = '8',
-    REAL_KEY_HOME_ALT = '1', // ESC [1~ (vt100? linux vt? or what?)
-    REAL_KEY_END_ALT = '4', // ESC [4~
-    REAL_KEY_HOME_XTERM = 'H',
-    REAL_KEY_END_XTERM = 'F',
-
-/* These are the special codes assigned by this program to the special keys */
-    KEY_UP = 20,
-    KEY_DOWN = 21,
-    KEY_RIGHT = 22,
-    KEY_LEFT = 23,
-    PAGE_UP = 24,
-    PAGE_DOWN = 25,
-    KEY_HOME = 26,
-    KEY_END = 27,
-
 /* Absolute max of lines eaten */
     MAXLINES = CONFIG_FEATURE_LESS_MAXLINES,
-
 /* This many "after the end" lines we will show (at max) */
     TILDES = 1,
@@ -75 +48 @@
 /* Command line options */
 enum {
-    FLAG_E = 1,
+    FLAG_E = 1 << 0,
     FLAG_M = 1 << 1,
     FLAG_m = 1 << 2,
     FLAG_N = 1 << 3,
     FLAG_TILDE = 1 << 4,
+    FLAG_I = 1 << 5,
+    FLAG_S = (1 << 6) * ENABLE_FEATURE_LESS_DASHCMD,
 /* hijack command line options variable for internal state vars */
     LESS_STATE_MATCH_BACKWARDS = 1 << 15,
@@ -91 +66 @@
     int cur_fline; /* signed */
     int kbd_fd;  /* fd to get input from */
+    int less_gets_pos;
 /* last position in last line, taking into account tabs */
-    size_t linepos;
-    unsigned max_displayed_line;
+    size_t last_line_pos;
     unsigned max_fline;
     unsigned max_lineno; /* this one tracks linewrap */
+    unsigned max_displayed_line;
     unsigned width;
+#if ENABLE_FEATURE_LESS_WINCH
+    unsigned winch_counter;
+#endif
     ssize_t eof_error; /* eof if 0, error if < 0 */
-    size_t readpos;
-    size_t readeof;
+    ssize_t readpos;
+    ssize_t readeof; /* must be signed */
     const char **buffer;
     const char **flines;
@@ -114 +93 @@
     unsigned *match_lines;
     int match_pos; /* signed! */
-    unsigned num_matches;
+    int wanted_match; /* signed! */
+    int num_matches;
     regex_t pattern;
     smallint pattern_valid;
@@ -120 +100 @@
     smallint terminated;
     struct termios term_orig, term_less;
+    char kbd_input[KEYCODE_BUFFER_SIZE];
 };
 #define G (*ptr_to_globals)
 #define cur_fline           (G.cur_fline         )
 #define kbd_fd              (G.kbd_fd            )
-#define linepos             (G.linepos           )
-#define max_displayed_line  (G.max_displayed_line)
+#define less_gets_pos       (G.less_gets_pos     )
+#define last_line_pos       (G.last_line_pos     )
 #define max_fline           (G.max_fline         )
 #define max_lineno          (G.max_lineno        )
+#define max_displayed_line  (G.max_displayed_line)
 #define width               (G.width             )
+#define winch_counter       (G.winch_counter     )
+/* This one is 100% not cached by compiler on read access */
+#define WINCH_COUNTER (*(volatile unsigned *)&winch_counter)
 #define eof_error           (G.eof_error         )
 #define readpos             (G.readpos           )
@@ -145 +130 @@
 #define match_pos           (G.match_pos         )
 #define num_matches         (G.num_matches       )
+#define wanted_match        (G.wanted_match      )
 #define pattern             (G.pattern           )
 #define pattern_valid       (G.pattern_valid     )
@@ -151 +137 @@
 #define term_orig           (G.term_orig         )
 #define term_less           (G.term_less         )
+#define kbd_input           (G.kbd_input         )
 #define INIT_G() do { \
-        PTR_TO_GLOBALS = xzalloc(sizeof(G)); \
-        empty_line_marker = "~"; \
-        num_files = 1; \
-        current_file = 1; \
-        eof_error = 1; \
-        terminated = 1; \
-    } while (0)
+    SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+    less_gets_pos = -1; \
+    empty_line_marker = "~"; \
+    num_files = 1; \
+    current_file = 1; \
+    eof_error = 1; \
+    terminated = 1; \
+    IF_FEATURE_LESS_REGEXP(wanted_match = -1;) \
+} while (0)
+
+/* flines[] are lines read from stdin, each in malloc'ed buffer.
+ * Line numbers are stored as uint32_t prepended to each line.
+ * Pointer is adjusted so that flines[i] points directly past
+ * line number. Accesor: */
+#define MEMPTR(p) ((char*)(p) - 4)
+#define LINENO(p) (*(uint32_t*)((p) - 4))
+
 
 /* Reset terminal input to normal */
 static void set_tty_cooked(void)
 {
-    fflush(stdout);
+    fflush_all();
     tcsetattr(kbd_fd, TCSANOW, &term_orig);
-}
-
-/* Exit the program gracefully */
-static void less_exit(int code)
-{
-    /* TODO: We really should save the terminal state when we start,
-     * and restore it when we exit. Less does this with the
-     * "ti" and "te" termcap commands; can this be done with
-     * only termios.h? */
-    putchar('\n');
-    fflush_stdout_and_exit(code);
 }
 
@@ -182 +168 @@
 static void move_cursor(int line, int row)
 {
-    printf("\033[%u;%uH", line, row);
+    printf(ESC"[%u;%uH", line, row);
 }
 
 static void clear_line(void)
 {
-    printf("\033[%u;0H" CLEAR_2_EOL, max_displayed_line + 2);
+    printf(ESC"[%u;0H" CLEAR_2_EOL, max_displayed_line + 2);
 }
 
@@ -200 +186 @@
     printf(HIGHLIGHT"%.*s"NORMAL, width - 1, str);
 }
+
+/* Exit the program gracefully */
+static void less_exit(int code)
+{
+    set_tty_cooked();
+    clear_line();
+    if (code < 0)
+        kill_myself_with_sig(- code); /* does not return */
+    exit(code);
+}
+
+#if (ENABLE_FEATURE_LESS_DASHCMD && ENABLE_FEATURE_LESS_LINENUMS) \
+ || ENABLE_FEATURE_LESS_WINCH
+static void re_wrap(void)
+{
+    int w = width;
+    int new_line_pos;
+    int src_idx;
+    int dst_idx;
+    int new_cur_fline = 0;
+    uint32_t lineno;
+    char linebuf[w + 1];
+    const char **old_flines = flines;
+    const char *s;
+    char **new_flines = NULL;
+    char *d;
+
+    if (option_mask32 & FLAG_N)
+        w -= 8;
+
+    src_idx = 0;
+    dst_idx = 0;
+    s = old_flines[0];
+    lineno = LINENO(s);
+    d = linebuf;
+    new_line_pos = 0;
+    while (1) {
+        *d = *s;
+        if (*d != '\0') {
+            new_line_pos++;
+            if (*d == '\t') /* tab */
+                new_line_pos += 7;
+            s++;
+            d++;
+            if (new_line_pos >= w) {
+                int sz;
+                /* new line is full, create next one */
+                *d = '\0';
+ next_new:
+                sz = (d - linebuf) + 1; /* + 1: NUL */
+                d = ((char*)xmalloc(sz + 4)) + 4;
+                LINENO(d) = lineno;
+                memcpy(d, linebuf, sz);
+                new_flines = xrealloc_vector(new_flines, 8, dst_idx);
+                new_flines[dst_idx] = d;
+                dst_idx++;
+                if (new_line_pos < w) {
+                    /* if we came here thru "goto next_new" */
+                    if (src_idx > max_fline)
+                        break;
+                    lineno = LINENO(s);
+                }
+                d = linebuf;
+                new_line_pos = 0;
+            }
+            continue;
+        }
+        /* *d == NUL: old line ended, go to next old one */
+        free(MEMPTR(old_flines[src_idx]));
+        /* btw, convert cur_fline... */
+        if (cur_fline == src_idx)
+            new_cur_fline = dst_idx;
+        src_idx++;
+        /* no more lines? finish last new line (and exit the loop) */
+        if (src_idx > max_fline)
+            goto next_new;
+        s = old_flines[src_idx];
+        if (lineno != LINENO(s)) {
+            /* this is not a continuation line!
+             * create next _new_ line too */
+            goto next_new;
+        }
+    }
+
+    free(old_flines);
+    flines = (const char **)new_flines;
+
+    max_fline = dst_idx - 1;
+    last_line_pos = new_line_pos;
+    cur_fline = new_cur_fline;
+    /* max_lineno is screen-size independent */
+#if ENABLE_FEATURE_LESS_REGEXP
+    pattern_valid = 0;
+#endif
+}
+#endif
 
 #if ENABLE_FEATURE_LESS_REGEXP
@@ -226 +308 @@
  * readbuf[0..readeof-1] - small preliminary buffer.
  * readbuf[readpos] - next character to add to current line.
- * linepos - screen line position of next char to be read
+ * last_line_pos - screen line position of next char to be read
  *      (takes into account tabs and backspaces)
  * eof_error - < 0 error, == 0 EOF, > 0 not EOF/error
@@ -234 +316 @@
 #define readbuf bb_common_bufsiz1
     char *current_line, *p;
-    USE_FEATURE_LESS_REGEXP(unsigned old_max_fline = max_fline;)
     int w = width;
     char last_terminated = terminated;
+#if ENABLE_FEATURE_LESS_REGEXP
+    unsigned old_max_fline = max_fline;
+    time_t last_time = 0;
+    unsigned seconds_p1 = 3; /* seconds_to_loop + 1 */
+#endif
 
     if (option_mask32 & FLAG_N)
         w -= 8;
 
-    current_line = xmalloc(w);
-    p = current_line;
+ IF_FEATURE_LESS_REGEXP(again0:)
+
+    p = current_line = ((char*)xmalloc(w + 4)) + 4;
     max_fline += last_terminated;
     if (!last_terminated) {
         const char *cp = flines[max_fline];
-        if (option_mask32 & FLAG_N)
-            cp += 8;
-        strcpy(current_line, cp);
+        strcpy(p, cp);
         p += strlen(current_line);
-        /* linepos is still valid from previous read_lines() */
+        free(MEMPTR(flines[max_fline]));
+        /* last_line_pos is still valid from previous read_lines() */
     } else {
-        linepos = 0;
-    }
-
-    while (1) {
- again:
+        last_line_pos = 0;
+    }
+
+    while (1) { /* read lines until we reach cur_fline or wanted_match */
         *p = '\0';
         terminated = 0;
-        while (1) {
+        while (1) { /* read chars until we have a line */
             char c;
             /* if no unprocessed chars left, eat more */
             if (readpos >= readeof) {
-                smallint yielded = 0;
-
                 ndelay_on(0);
- read_again:
-                eof_error = safe_read(0, readbuf, sizeof(readbuf));
+                eof_error = safe_read(STDIN_FILENO, readbuf, sizeof(readbuf));
+                ndelay_off(0);
                 readpos = 0;
                 readeof = eof_error;
-                if (eof_error < 0) {
-                    if (errno == EAGAIN && !yielded) {
-            /* We can hit EAGAIN while searching for regexp match.
-             * Yield is not 100% reliable solution in general,
-             * but for less it should be good enough -
-             * we give stdin supplier some CPU time to produce
-             * more input. We do it just once.
-             * Currently, we do not stop when we found the Nth
-             * occurrence we were looking for. We read till end
-             * (or double EAGAIN). TODO? */
-                        sched_yield();
-                        yielded = 1;
-                        goto read_again;
-                    }
-                    readeof = 0;
-                    if (errno != EAGAIN)
-                        print_statusline("read error");
-                }
-                ndelay_off(0);
-
-                if (eof_error <= 0) {
+                if (eof_error <= 0)
                     goto reached_eof;
-                }
             }
             c = readbuf[readpos];
@@ -298 +360 @@
             /* <tab><bs> is (a) insane and */
             /* (b) harder to do correctly, so we refuse to do it */
-            if (c == '\x8' && linepos && p[-1] != '\t') {
+            if (c == '\x8' && last_line_pos && p[-1] != '\t') {
                 readpos++; /* eat it */
-                linepos--;
+                last_line_pos--;
             /* was buggy (p could end up <= current_line)... */
                 *--p = '\0';
@@ -306 +368 @@
             }
             {
-                size_t new_linepos = linepos + 1;
+                size_t new_last_line_pos = last_line_pos + 1;
                 if (c == '\t') {
-                    new_linepos += 7;
-                    new_linepos &= (~7);
+                    new_last_line_pos += 7;
+                    new_last_line_pos &= (~7);
                 }
-                if (new_linepos >= w)
+                if ((int)new_last_line_pos >= w)
                     break;
-                linepos = new_linepos;
+                last_line_pos = new_last_line_pos;
             }
             /* ok, we will eat this char */
@@ -319 +381 @@
             if (c == '\n') {
                 terminated = 1;
-                linepos = 0;
+                last_line_pos = 0;
                 break;
             }
@@ -326 +388 @@
             *p++ = c;
             *p = '\0';
-        }
+        } /* end of "read chars until we have a line" loop */
         /* Corner case: linewrap with only "" wrapping to next line */
         /* Looks ugly on screen, so we do not store this empty line */
@@ -332 +394 @@
             last_terminated = 1;
             max_lineno++;
-            goto again;
+            continue;
         }
  reached_eof:
         last_terminated = terminated;
-        flines = xrealloc(flines, (max_fline+1) * sizeof(char *));
-        if (option_mask32 & FLAG_N) {
-            /* Width of 7 preserves tab spacing in the text */
-            flines[max_fline] = xasprintf(
-                (max_lineno <= 9999999) ? "%7u %s" : "%07u %s",
-                max_lineno % 10000000, current_line);
-            free(current_line);
-            if (terminated)
-                max_lineno++;
-        } else {
-            flines[max_fline] = xrealloc(current_line, strlen(current_line)+1);
-        }
+        flines = xrealloc_vector(flines, 8, max_fline);
+
+        flines[max_fline] = (char*)xrealloc(MEMPTR(current_line), strlen(current_line) + 1 + 4) + 4;
+        LINENO(flines[max_fline]) = max_lineno;
+        if (terminated)
+            max_lineno++;
+
         if (max_fline >= MAXLINES) {
             eof_error = 0; /* Pretend we saw EOF */
             break;
         }
-        if (max_fline > cur_fline + max_displayed_line)
+        if (!(option_mask32 & FLAG_S)
+          ? (max_fline > cur_fline + max_displayed_line)
+          : (max_fline >= cur_fline
+             && max_lineno > LINENO(flines[cur_fline]) + max_displayed_line)
+        ) {
+#if !ENABLE_FEATURE_LESS_REGEXP
             break;
+#else
+            if (wanted_match >= num_matches) { /* goto_match called us */
+                fill_match_lines(old_max_fline);
+                old_max_fline = max_fline;
+            }
+            if (wanted_match < num_matches)
+                break;
+#endif
+        }
         if (eof_error <= 0) {
-            if (eof_error < 0 && errno == EAGAIN) {
-                /* not yet eof or error, reset flag (or else
-                 * we will hog CPU - select() will return
-                 * immediately */
-                eof_error = 1;
+            if (eof_error < 0) {
+                if (errno == EAGAIN) {
+                    /* not yet eof or error, reset flag (or else
+                     * we will hog CPU - select() will return
+                     * immediately */
+                    eof_error = 1;
+                } else {
+                    print_statusline(bb_msg_read_error);
+                }
             }
+#if !ENABLE_FEATURE_LESS_REGEXP
             break;
+#else
+            if (wanted_match < num_matches) {
+                break;
+            } else { /* goto_match called us */
+                time_t t = time(NULL);
+                if (t != last_time) {
+                    last_time = t;
+                    if (--seconds_p1 == 0)
+                        break;
+                }
+                sched_yield();
+                goto again0; /* go loop again (max 2 seconds) */
+            }
+#endif
         }
         max_fline++;
-        current_line = xmalloc(w);
+        current_line = ((char*)xmalloc(w + 4)) + 4;
         p = current_line;
-        linepos = 0;
-    }
+        last_line_pos = 0;
+    } /* end of "read lines until we reach cur_fline" loop */
     fill_match_lines(old_max_fline);
+#if ENABLE_FEATURE_LESS_REGEXP
+    /* prevent us from being stuck in search for a match */
+    wanted_match = -1;
+#endif
 #undef readbuf
 }
@@ -385 +479 @@
 {
     int percentage;
+
+    if (less_gets_pos >= 0) /* don't touch statusline while input is done! */
+        return;
 
     clear_line();
@@ -393 +490 @@
             cur_fline + 1, cur_fline + max_displayed_line + 1,
             max_fline + 1);
-    if (cur_fline >= max_fline - max_displayed_line) {
+    if (cur_fline >= (int)(max_fline - max_displayed_line)) {
         printf("(END)"NORMAL);
         if (num_files > 1 && current_file != num_files)
@@ -408 +505 @@
 {
     const char *p;
+
+    if (less_gets_pos >= 0) /* don't touch statusline while input is done! */
+        return;
 
     /* Change the status if flags have been set */
@@ -419 +519 @@
 
     clear_line();
-    if (cur_fline && cur_fline < max_fline - max_displayed_line) {
-        putchar(':');
+    if (cur_fline && cur_fline < (int)(max_fline - max_displayed_line)) {
+        bb_putchar(':');
         return;
     }
@@ -445 +545 @@
         diff = max_fline - (cur_fline + max_displayed_line) + TILDES;
         /* As the number of lines requested was too large, we just move
-        to the end of the file */
+         * to the end of the file */
         if (diff > 0)
             cur_fline += diff;
@@ -457 +557 @@
     "\x7f\x9b"; /* DEL and infamous Meta-ESC :( */
 static const char ctrlconv[] ALIGN1 =
-    /* '\n': it's a former NUL - subst with '@', not 'J' */
+    /* why 40 instead of 4a below? - it is a replacement for '\n'.
+     * '\n' is a former NUL - we subst it with @, not J */
     "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x40\x4b\x4c\x4d\x4e\x4f"
     "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f";
+
+static void lineno_str(char *nbuf9, const char *line)
+{
+    nbuf9[0] = '\0';
+    if (option_mask32 & FLAG_N) {
+        const char *fmt;
+        unsigned n;
+
+        if (line == empty_line_marker) {
+            memset(nbuf9, ' ', 8);
+            nbuf9[8] = '\0';
+            return;
+        }
+        /* Width of 7 preserves tab spacing in the text */
+        fmt = "%7u ";
+        n = LINENO(line) + 1;
+        if (n > 9999999) {
+            n %= 10000000;
+            fmt = "%07u ";
+        }
+        sprintf(nbuf9, fmt, n);
+    }
+}
+
 
 #if ENABLE_FEATURE_LESS_REGEXP
@@ -470 +595 @@
 
     char buf[width];
+    char nbuf9[9];
     const char *str = line;
     char *p = buf;
@@ -502 +628 @@
     while (match_status == 0) {
         char *new = xasprintf("%s%.*s"HIGHLIGHT"%.*s"NORMAL,
-                growline ? : "",
+                growline ? growline : "",
                 match_structs.rm_so, str,
                 match_structs.rm_eo - match_structs.rm_so,
                         str + match_structs.rm_so);
-        free(growline); growline = new;
+        free(growline);
+        growline = new;
         str += match_structs.rm_eo;
         line += match_structs.rm_eo;
@@ -513 +640 @@
         /* Most of the time doesn't find the regex, optimize for that */
         match_status = regexec(&pattern, line, 1, &match_structs, eflags);
-    }
-
+        /* if even "" matches, treat it as "not a match" */
+        if (match_structs.rm_so >= match_structs.rm_eo)
+            match_status = 1;
+    }
+
+    lineno_str(nbuf9, line);
     if (!growline) {
-        printf(CLEAR_2_EOL"%s\n", str);
+        printf(CLEAR_2_EOL"%s%s\n", nbuf9, str);
         return;
     }
-    printf(CLEAR_2_EOL"%s%s\n", growline, str);
+    printf(CLEAR_2_EOL"%s%s%s\n", nbuf9, growline, str);
     free(growline);
 }
@@ -529 +660 @@
 {
     char buf[width];
+    char nbuf9[9];
     char *p;
     size_t n;
 
-    printf(CLEAR_2_EOL);
+    lineno_str(nbuf9, str);
+    printf(CLEAR_2_EOL"%s", nbuf9);
+
     while (*str) {
         n = strcspn(str, controls);
@@ -562 +696 @@
 static void buffer_print(void)
 {
-    int i;
+    unsigned i;
 
     move_cursor(0, 0);
@@ -575 +709 @@
 static void buffer_fill_and_print(void)
 {
-    int i;
+    unsigned i;
+#if ENABLE_FEATURE_LESS_DASHCMD
+    int fpos = cur_fline;
+
+    if (option_mask32 & FLAG_S) {
+        /* Go back to the beginning of this line */
+        while (fpos && LINENO(flines[fpos]) == LINENO(flines[fpos-1]))
+            fpos--;
+    }
+
+    i = 0;
+    while (i <= max_displayed_line && fpos <= max_fline) {
+        int lineno = LINENO(flines[fpos]);
+        buffer[i] = flines[fpos];
+        i++;
+        do {
+            fpos++;
+        } while ((fpos <= max_fline)
+              && (option_mask32 & FLAG_S)
+              && lineno == LINENO(flines[fpos])
+        );
+    }
+#else
     for (i = 0; i <= max_displayed_line && cur_fline + i <= max_fline; i++) {
         buffer[i] = flines[cur_fline + i];
     }
+#endif
     for (; i <= max_displayed_line; i++) {
         buffer[i] = empty_line_marker;
@@ -619 +776 @@
 {
     if (filename) {
-        int fd = xopen(filename, O_RDONLY);
-        dup2(fd, 0);
-        if (fd) close(fd);
+        xmove_fd(xopen(filename, O_RDONLY), STDIN_FILENO);
     } else {
         /* "less" with no arguments in argv[] */
@@ -629 +784 @@
     readpos = 0;
     readeof = 0;
-    linepos = 0;
+    last_line_pos = 0;
     terminated = 1;
     read_lines();
@@ -637 +792 @@
 static void reinitialize(void)
 {
-    int i;
+    unsigned i;
 
     if (flines) {
         for (i = 0; i <= max_fline; i++)
-            free((void*)(flines[i]));
+            free(MEMPTR(flines[i]));
         free(flines);
         flines = NULL;
@@ -653 +808 @@
 }
 
-static void getch_nowait(char* input, int sz)
-{
-    ssize_t rd;
-    fd_set readfds;
+static int getch_nowait(void)
+{
+    int rd;
+    struct pollfd pfd[2];
+
+    pfd[0].fd = STDIN_FILENO;
+    pfd[0].events = POLLIN;
+    pfd[1].fd = kbd_fd;
+    pfd[1].events = POLLIN;
  again:
-    fflush(stdout);
-
-    /* NB: select returns whenever read will not block. Therefore:
-     * (a) with O_NONBLOCK'ed fds select will return immediately
-     * (b) if eof is reached, select will also return
-     *     because read will immediately return 0 bytes.
-     * Even if select says that input is available, read CAN block
+    tcsetattr(kbd_fd, TCSANOW, &term_less);
+    /* NB: select/poll returns whenever read will not block. Therefore:
+     * if eof is reached, select/poll will return immediately
+     * because read will immediately return 0 bytes.
+     * Even if select/poll says that input is available, read CAN block
      * (switch fd into O_NONBLOCK'ed mode to avoid it)
      */
-    FD_ZERO(&readfds);
-    if (max_fline <= cur_fline + max_displayed_line
-     && eof_error > 0 /* did NOT reach eof yet */
+    rd = 1;
+    /* Are we interested in stdin? */
+//TODO: reuse code for determining this
+    if (!(option_mask32 & FLAG_S)
+       ? !(max_fline > cur_fline + max_displayed_line)
+       : !(max_fline >= cur_fline
+           && max_lineno > LINENO(flines[cur_fline]) + max_displayed_line)
     ) {
-        /* We are interested in stdin */
-        FD_SET(0, &readfds);
-    }
-    FD_SET(kbd_fd, &readfds);
-    tcsetattr(kbd_fd, TCSANOW, &term_less);
-    select(kbd_fd + 1, &readfds, NULL, NULL, NULL);
-
-    input[0] = '\0';
-    ndelay_on(kbd_fd);
-    rd = read(kbd_fd, input, sz);
-    ndelay_off(kbd_fd);
-    if (rd < 0) {
-        /* No keyboard input, but we have input on stdin! */
-        if (errno != EAGAIN) /* Huh?? */
-            return;
-        read_lines();
-        buffer_fill_and_print();
+        if (eof_error > 0) /* did NOT reach eof yet */
+            rd = 0; /* yes, we are interested in stdin */
+    }
+    /* Position cursor if line input is done */
+    if (less_gets_pos >= 0)
+        move_cursor(max_displayed_line + 2, less_gets_pos + 1);
+    fflush_all();
+
+    if (kbd_input[0] == 0) { /* if nothing is buffered */
+#if ENABLE_FEATURE_LESS_WINCH
+        while (1) {
+            int r;
+            /* NB: SIGWINCH interrupts poll() */
+            r = poll(pfd + rd, 2 - rd, -1);
+            if (/*r < 0 && errno == EINTR &&*/ winch_counter)
+                return '\\'; /* anything which has no defined function */
+            if (r) break;
+        }
+#else
+        safe_poll(pfd + rd, 2 - rd, -1);
+#endif
+    }
+
+    /* We have kbd_fd in O_NONBLOCK mode, read inside read_key()
+     * would not block even if there is no input available */
+    rd = read_key(kbd_fd, kbd_input, /*timeout off:*/ -2);
+    if (rd == -1) {
+        if (errno == EAGAIN) {
+            /* No keyboard input available. Since poll() did return,
+             * we should have input on stdin */
+            read_lines();
+            buffer_fill_and_print();
+            goto again;
+        }
+        /* EOF/error (ssh session got killed etc) */
+        less_exit(0);
+    }
+    set_tty_cooked();
+    return rd;
+}
+
+/* Grab a character from input without requiring the return key.
+ * May return KEYCODE_xxx values.
+ * Note that this function works best with raw input. */
+static int less_getch(int pos)
+{
+    int i;
+
+ again:
+    less_gets_pos = pos;
+    i = getch_nowait();
+    less_gets_pos = -1;
+
+    /* Discard Ctrl-something chars */
+    if (i >= 0 && i < ' ' && i != 0x0d && i != 8)
         goto again;
-    }
-}
-
-/* Grab a character from input without requiring the return key. If the
- * character is ASCII \033, get more characters and assign certain sequences
- * special return codes. Note that this function works best with raw input. */
-static int less_getch(void)
-{
-    char input[16];
-    unsigned i;
- again:
-    memset(input, 0, sizeof(input));
-    getch_nowait(input, sizeof(input));
-
-    /* Detect escape sequences (i.e. arrow keys) and handle
-     * them accordingly */
-    if (input[0] == '\033' && input[1] == '[') {
-        set_tty_cooked();
-        i = input[2] - REAL_KEY_UP;
-        if (i < 4)
-            return 20 + i;
-        i = input[2] - REAL_PAGE_UP;
-        if (i < 4)
-            return 24 + i;
-        if (input[2] == REAL_KEY_HOME_XTERM)
-            return KEY_HOME;
-        if (input[2] == REAL_KEY_HOME_ALT)
-            return KEY_HOME;
-        if (input[2] == REAL_KEY_END_XTERM)
-            return KEY_END;
-        if (input[2] == REAL_KEY_END_ALT)
-            return KEY_END;
-        return 0;
-    }
-    /* Reject almost all control chars */
-    i = input[0];
-    if (i < ' ' && i != 0x0d && i != 8) goto again;
-    set_tty_cooked();
     return i;
 }
@@ -732 +894 @@
 static char* less_gets(int sz)
 {
-    char c;
-    int i = 0;
+    int c;
+    unsigned i = 0;
     char *result = xzalloc(1);
+
     while (1) {
-        fflush(stdout);
-
-        /* I be damned if I know why is it needed *repeatedly*,
-         * but it is needed. Is it because of stdio? */
-        tcsetattr(kbd_fd, TCSANOW, &term_less);
-
         c = '\0';
-        read(kbd_fd, &c, 1);
-        if (c == 0x0d)
+        less_gets_pos = sz + i;
+        c = getch_nowait();
+        if (c == 0x0d) {
+            result[i] = '\0';
+            less_gets_pos = -1;
             return result;
+        }
         if (c == 0x7f)
             c = 8;
@@ -752 +913 @@
             i--;
         }
-        if (c < ' ')
+        if (c < ' ') /* filters out KEYCODE_xxx too (<0) */
             continue;
         if (i >= width - sz - 1)
             continue; /* len limit */
-        putchar(c);
+        bb_putchar(c);
         result[i++] = c;
         result = xrealloc(result, i+1);
-        result[i] = '\0';
     }
 }
@@ -765 +925 @@
 static void examine_file(void)
 {
+    char *new_fname;
+
     print_statusline("Examine: ");
+    new_fname = less_gets(sizeof("Examine: ") - 1);
+    if (!new_fname[0]) {
+        status_print();
+ err:
+        free(new_fname);
+        return;
+    }
+    if (access(new_fname, R_OK) != 0) {
+        print_statusline("Cannot read this file");
+        goto err;
+    }
     free(filename);
-    filename = less_gets(sizeof("Examine: ")-1);
+    filename = new_fname;
     /* files start by = argv. why we assume that argv is infinitely long??
     files[num_files] = filename;
@@ -795 +968 @@
 static void remove_current_file(void)
 {
-    int i;
+    unsigned i;
 
     if (num_files < 2)
@@ -821 +994 @@
     print_statusline(" :");
 
-    keypress = less_getch();
+    keypress = less_getch(2);
     switch (keypress) {
     case 'd':
@@ -841 +1014 @@
         break;
     case 'q':
-        less_exit(0);
+        less_exit(EXIT_SUCCESS);
         break;
     case 'x':
@@ -861 +1034 @@
 static void goto_match(int match)
 {
-    int sv;
-
     if (!pattern_valid)
         return;
     if (match < 0)
         match = 0;
-    sv = cur_fline;
     /* Try to find next match if eof isn't reached yet */
     if (match >= num_matches && eof_error > 0) {
-        cur_fline = MAXLINES; /* look as far as needed */
+        wanted_match = match; /* "I want to read until I see N'th match" */
         read_lines();
     }
     if (num_matches) {
-        cap_cur_fline(cur_fline);
         normalize_match_pos(match);
         buffer_line(match_lines[match_pos]);
     } else {
-        cur_fline = sv;
         print_statusline("No matches found");
     }
@@ -894 +1062 @@
          && !(num_matches && match_lines[num_matches-1] == pos)
         ) {
-            match_lines = xrealloc(match_lines, (num_matches+1) * sizeof(int));
+            match_lines = xrealloc_vector(match_lines, 4, num_matches);
             match_lines[num_matches++] = pos;
         }
@@ -917 +1085 @@
     /* Get the uncompiled regular expression from the user */
     clear_line();
-    putchar((option_mask32 & LESS_STATE_MATCH_BACKWARDS) ? '?' : '/');
+    bb_putchar((option_mask32 & LESS_STATE_MATCH_BACKWARDS) ? '?' : '/');
     uncomp_regex = less_gets(1);
     if (!uncomp_regex[0]) {
@@ -926 +1094 @@
 
     /* Compile the regex and check for errors */
-    err = regcomp_or_errmsg(&pattern, uncomp_regex, 0);
+    err = regcomp_or_errmsg(&pattern, uncomp_regex,
+                (option_mask32 & FLAG_I) ? REG_ICASE : 0);
     free(uncomp_regex);
     if (err) {
@@ -938 +1107 @@
     fill_match_lines(0);
     while (match_pos < num_matches) {
-        if (match_lines[match_pos] > cur_fline)
+        if ((int)match_lines[match_pos] > cur_fline)
             break;
         match_pos++;
@@ -954 +1123 @@
 static void number_process(int first_digit)
 {
-    int i = 1;
+    unsigned i;
     int num;
+    int keypress;
     char num_input[sizeof(int)*4]; /* more than enough */
-    char keypress;
 
     num_input[0] = first_digit;
@@ -966 +1135 @@
 
     /* Receive input until a letter is given */
+    i = 1;
     while (i < sizeof(num_input)-1) {
-        num_input[i] = less_getch();
-        if (!num_input[i] || !isdigit(num_input[i]))
+        keypress = less_getch(i + 1);
+        if ((unsigned)keypress > 255 || !isdigit(num_input[i]))
             break;
-        putchar(num_input[i]);
+        num_input[i] = keypress;
+        bb_putchar(keypress);
         i++;
     }
 
-    /* Take the final letter out of the digits string */
-    keypress = num_input[i];
     num_input[i] = '\0';
     num = bb_strtou(num_input, NULL, 10);
@@ -986 +1155 @@
     /* We now know the number and the letter entered, so we process them */
     switch (keypress) {
-    case KEY_DOWN: case 'z': case 'd': case 'e': case ' ': case '\015':
+    case KEYCODE_DOWN: case 'z': case 'd': case 'e': case ' ': case '\015':
         buffer_down(num);
         break;
-    case KEY_UP: case 'b': case 'w': case 'y': case 'u':
+    case KEYCODE_UP: case 'b': case 'w': case 'y': case 'u':
         buffer_up(num);
         break;
@@ -1019 +1188 @@
 }
 
-#if ENABLE_FEATURE_LESS_FLAGCS
+#if ENABLE_FEATURE_LESS_DASHCMD
 static void flag_change(void)
 {
@@ -1025 +1194 @@
 
     clear_line();
-    putchar('-');
-    keypress = less_getch();
+    bb_putchar('-');
+    keypress = less_getch(1);
 
     switch (keypress) {
@@ -1041 +1210 @@
         option_mask32 ^= FLAG_TILDE;
         break;
-    }
-}
-
+    case 'S':
+        option_mask32 ^= FLAG_S;
+        buffer_fill_and_print();
+        break;
+#if ENABLE_FEATURE_LESS_LINENUMS
+    case 'N':
+        option_mask32 ^= FLAG_N;
+        re_wrap();
+        buffer_fill_and_print();
+        break;
+#endif
+    }
+}
+
+#ifdef BLOAT
 static void show_flag_status(void)
 {
@@ -1050 +1231 @@
 
     clear_line();
-    putchar('_');
-    keypress = less_getch();
+    bb_putchar('_');
+    keypress = less_getch(1);
 
     switch (keypress) {
@@ -1079 +1260 @@
 #endif
 
+#endif /* ENABLE_FEATURE_LESS_DASHCMD */
+
 static void save_input_to_file(void)
 {
     const char *msg = "";
     char *current_line;
-    int i;
+    unsigned i;
     FILE *fp;
 
     print_statusline("Log file: ");
     current_line = less_gets(sizeof("Log file: ")-1);
-    if (strlen(current_line) > 0) {
-        fp = fopen(current_line, "w");
+    if (current_line[0]) {
+        fp = fopen_for_write(current_line);
         if (!fp) {
             msg = "Error opening log file";
@@ -1110 +1293 @@
 
     print_statusline("Mark: ");
-    letter = less_getch();
+    letter = less_getch(sizeof("Mark: ") - 1);
 
     if (isalpha(letter)) {
@@ -1131 +1314 @@
 
     print_statusline("Go to mark: ");
-    letter = less_getch();
+    letter = less_getch(sizeof("Go to mark: ") - 1);
     clear_line();
 
@@ -1151 +1334 @@
 {
     switch (bracket) {
-    case '{': case '[':
-        return bracket + 2;
-    case '(':
-        return ')';
-    case '}': case ']':
-        return bracket - 2;
-    case ')':
-        return '(';
-    }
-    return 0;
+        case '{': case '[': /* '}' == '{' + 2. Same for '[' */
+            bracket++;
+        case '(':           /* ')' == '(' + 1 */
+            bracket++;
+            break;
+        case '}': case ']':
+            bracket--;
+        case ')':
+            bracket--;
+            break;
+    };
+    return bracket;
 }
 
 static void match_right_bracket(char bracket)
 {
-    int bracket_line = -1;
-    int i;
+    unsigned i;
 
     if (strchr(flines[cur_fline], bracket) == NULL) {
@@ -1172 +1356 @@
         return;
     }
+    bracket = opp_bracket(bracket);
     for (i = cur_fline + 1; i < max_fline; i++) {
-        if (strchr(flines[i], opp_bracket(bracket)) != NULL) {
-            bracket_line = i;
-            break;
-        }
-    }
-    if (bracket_line == -1)
-        print_statusline("No matching bracket found");
-    buffer_line(bracket_line - max_displayed_line);
+        if (strchr(flines[i], bracket) != NULL) {
+            buffer_line(i);
+            return;
+        }
+    }
+    print_statusline("No matching bracket found");
 }
 
 static void match_left_bracket(char bracket)
 {
-    int bracket_line = -1;
     int i;
 
@@ -1193 +1375 @@
     }
 
+    bracket = opp_bracket(bracket);
     for (i = cur_fline + max_displayed_line; i >= 0; i--) {
-        if (strchr(flines[i], opp_bracket(bracket)) != NULL) {
-            bracket_line = i;
-            break;
-        }
-    }
-    if (bracket_line == -1)
-        print_statusline("No matching bracket found");
-    buffer_line(bracket_line);
+        if (strchr(flines[i], bracket) != NULL) {
+            buffer_line(i);
+            return;
+        }
+    }
+    print_statusline("No matching bracket found");
 }
 #endif  /* FEATURE_LESS_BRACKETS */
@@ -1208 +1389 @@
 {
     switch (keypress) {
-    case KEY_DOWN: case 'e': case 'j': case 0x0d:
+    case KEYCODE_DOWN: case 'e': case 'j': case 0x0d:
         buffer_down(1);
         break;
-    case KEY_UP: case 'y': case 'k':
+    case KEYCODE_UP: case 'y': case 'k':
         buffer_up(1);
         break;
-    case PAGE_DOWN: case ' ': case 'z':
+    case KEYCODE_PAGEDOWN: case ' ': case 'z': case 'f':
         buffer_down(max_displayed_line + 1);
         break;
-    case PAGE_UP: case 'w': case 'b':
+    case KEYCODE_PAGEUP: case 'w': case 'b':
         buffer_up(max_displayed_line + 1);
         break;
@@ -1226 +1407 @@
         buffer_up((max_displayed_line + 1) / 2);
         break;
-    case KEY_HOME: case 'g': case 'p': case '<': case '%':
+    case KEYCODE_HOME: case 'g': case 'p': case '<': case '%':
         buffer_line(0);
         break;
-    case KEY_END: case 'G': case '>':
+    case KEYCODE_END: case 'G': case '>':
         cur_fline = MAXLINES;
         read_lines();
@@ -1235 +1416 @@
         break;
     case 'q': case 'Q':
-        less_exit(0);
+        less_exit(EXIT_SUCCESS);
         break;
 #if ENABLE_FEATURE_LESS_MARKS
@@ -1280 +1461 @@
         break;
 #endif
-#if ENABLE_FEATURE_LESS_FLAGCS
+#if ENABLE_FEATURE_LESS_DASHCMD
     case '-':
         flag_change();
         buffer_print();
         break;
+#ifdef BLOAT
     case '_':
         show_flag_status();
         break;
+#endif
 #endif
 #if ENABLE_FEATURE_LESS_BRACKETS
@@ -1306 +1489 @@
 }
 
-static void sig_catcher(int sig ATTRIBUTE_UNUSED)
-{
-    set_tty_cooked();
-    exit(1);
-}
-
-int less_main(int argc, char **argv);
+static void sig_catcher(int sig)
+{
+    less_exit(- sig);
+}
+
+#if ENABLE_FEATURE_LESS_WINCH
+static void sigwinch_handler(int sig UNUSED_PARAM)
+{
+    winch_counter++;
+}
+#endif
+
+int less_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int less_main(int argc, char **argv)
 {
@@ -1322 +1511 @@
     /* -xxx: newline also */
     /* -w N: assume width N (-xxx -w 32: hex viewer of sorts) */
-    getopt32(argv, "EMmN~");
+    getopt32(argv, "EMmN~I" IF_FEATURE_LESS_DASHCMD("S"));
     argc -= optind;
     argv += optind;
@@ -1331 +1520 @@
      * is not a tty and turns into cat. This makes sense. */
     if (!isatty(STDOUT_FILENO))
-        return bb_cat(argv);
-    kbd_fd = open(CURRENT_TTY, O_RDONLY);
-    if (kbd_fd < 0)
         return bb_cat(argv);
 
@@ -1342 +1528 @@
             bb_show_usage();
         }
-    } else
+    } else {
         filename = xstrdup(files[0]);
-
-    get_terminal_width_height(kbd_fd, &width, &max_displayed_line);
-    /* 20: two tabstops + 4 */
-    if (width < 20 || max_displayed_line < 3)
-        bb_error_msg_and_die("too narrow here");
-    max_displayed_line -= 2;
-
-    buffer = xmalloc((max_displayed_line+1) * sizeof(char *));
+    }
+
     if (option_mask32 & FLAG_TILDE)
         empty_line_marker = "";
 
+    kbd_fd = open(CURRENT_TTY, O_RDONLY);
+    if (kbd_fd < 0)
+        return bb_cat(argv);
+    ndelay_on(kbd_fd);
+
     tcgetattr(kbd_fd, &term_orig);
-    signal(SIGTERM, sig_catcher);
-    signal(SIGINT, sig_catcher);
     term_less = term_orig;
     term_less.c_lflag &= ~(ICANON | ECHO);
@@ -1365 +1548 @@
     term_less.c_cc[VTIME] = 0;
 
-    /* Want to do it just once, but it doesn't work, */
-    /* so we are redoing it (see code above). Mystery... */
-    /*tcsetattr(kbd_fd, TCSANOW, &term_less);*/
-
+    get_terminal_width_height(kbd_fd, &width, &max_displayed_line);
+    /* 20: two tabstops + 4 */
+    if (width < 20 || max_displayed_line < 3)
+        return bb_cat(argv);
+    max_displayed_line -= 2;
+
+    /* We want to restore term_orig on exit */
+    bb_signals(BB_FATAL_SIGS, sig_catcher);
+#if ENABLE_FEATURE_LESS_WINCH
+    signal(SIGWINCH, sigwinch_handler);
+#endif
+
+    buffer = xmalloc((max_displayed_line+1) * sizeof(char *));
     reinitialize();
     while (1) {
-        keypress = less_getch();
+#if ENABLE_FEATURE_LESS_WINCH
+        while (WINCH_COUNTER) {
+ again:
+            winch_counter--;
+            get_terminal_width_height(kbd_fd, &width, &max_displayed_line);
+            /* 20: two tabstops + 4 */
+            if (width < 20)
+                width = 20;
+            if (max_displayed_line < 3)
+                max_displayed_line = 3;
+            max_displayed_line -= 2;
+            free(buffer);
+            buffer = xmalloc((max_displayed_line+1) * sizeof(char *));
+            /* Avoid re-wrap and/or redraw if we already know
+             * we need to do it again. These ops are expensive */
+            if (WINCH_COUNTER)
+                goto again;
+            re_wrap();
+            if (WINCH_COUNTER)
+                goto again;
+            buffer_fill_and_print();
+            /* This took some time. Loop back and check,
+             * were there another SIGWINCH? */
+        }
+#endif
+        keypress = less_getch(-1); /* -1: do not position cursor */
         keypress_process(keypress);
     }
 }
+
+/*
+Help text of less version 418 is below.
+If you are implementing something, keeping
+key and/or command line switch compatibility is a good idea:
+
+
+                   SUMMARY OF LESS COMMANDS
+
+      Commands marked with * may be preceded by a number, N.
+      Notes in parentheses indicate the behavior if N is given.
+  h  H                 Display this help.
+  q  :q  Q  :Q  ZZ     Exit.
+ ---------------------------------------------------------------------------
+                           MOVING
+  e  ^E  j  ^N  CR  *  Forward  one line   (or N lines).
+  y  ^Y  k  ^K  ^P  *  Backward one line   (or N lines).
+  f  ^F  ^V  SPACE  *  Forward  one window (or N lines).
+  b  ^B  ESC-v      *  Backward one window (or N lines).
+  z                 *  Forward  one window (and set window to N).
+  w                 *  Backward one window (and set window to N).
+  ESC-SPACE         *  Forward  one window, but don't stop at end-of-file.
+  d  ^D             *  Forward  one half-window (and set half-window to N).
+  u  ^U             *  Backward one half-window (and set half-window to N).
+  ESC-)  RightArrow *  Left  one half screen width (or N positions).
+  ESC-(  LeftArrow  *  Right one half screen width (or N positions).
+  F                    Forward forever; like "tail -f".
+  r  ^R  ^L            Repaint screen.
+  R                    Repaint screen, discarding buffered input.
+        ---------------------------------------------------
+        Default "window" is the screen height.
+        Default "half-window" is half of the screen height.
+ ---------------------------------------------------------------------------
+                          SEARCHING
+  /pattern          *  Search forward for (N-th) matching line.
+  ?pattern          *  Search backward for (N-th) matching line.
+  n                 *  Repeat previous search (for N-th occurrence).
+  N                 *  Repeat previous search in reverse direction.
+  ESC-n             *  Repeat previous search, spanning files.
+  ESC-N             *  Repeat previous search, reverse dir. & spanning files.
+  ESC-u                Undo (toggle) search highlighting.
+        ---------------------------------------------------
+        Search patterns may be modified by one or more of:
+        ^N or !  Search for NON-matching lines.
+        ^E or *  Search multiple files (pass thru END OF FILE).
+        ^F or @  Start search at FIRST file (for /) or last file (for ?).
+        ^K       Highlight matches, but don't move (KEEP position).
+        ^R       Don't use REGULAR EXPRESSIONS.
+ ---------------------------------------------------------------------------
+                           JUMPING
+  g  <  ESC-<       *  Go to first line in file (or line N).
+  G  >  ESC->       *  Go to last line in file (or line N).
+  p  %              *  Go to beginning of file (or N percent into file).
+  t                 *  Go to the (N-th) next tag.
+  T                 *  Go to the (N-th) previous tag.
+  {  (  [           *  Find close bracket } ) ].
+  }  )  ]           *  Find open bracket { ( [.
+  ESC-^F <c1> <c2>  *  Find close bracket <c2>.
+  ESC-^B <c1> <c2>  *  Find open bracket <c1>
+        ---------------------------------------------------
+        Each "find close bracket" command goes forward to the close bracket
+          matching the (N-th) open bracket in the top line.
+        Each "find open bracket" command goes backward to the open bracket
+          matching the (N-th) close bracket in the bottom line.
+  m<letter>            Mark the current position with <letter>.
+  '<letter>            Go to a previously marked position.
+  ''                   Go to the previous position.
+  ^X^X                 Same as '.
+        ---------------------------------------------------
+        A mark is any upper-case or lower-case letter.
+        Certain marks are predefined:
+             ^  means  beginning of the file
+             $  means  end of the file
+ ---------------------------------------------------------------------------
+                        CHANGING FILES
+  :e [file]            Examine a new file.
+  ^X^V                 Same as :e.
+  :n                *  Examine the (N-th) next file from the command line.
+  :p                *  Examine the (N-th) previous file from the command line.
+  :x                *  Examine the first (or N-th) file from the command line.
+  :d                   Delete the current file from the command line list.
+  =  ^G  :f            Print current file name.
+ ---------------------------------------------------------------------------
+                    MISCELLANEOUS COMMANDS
+  -<flag>              Toggle a command line option [see OPTIONS below].
+  --<name>             Toggle a command line option, by name.
+  _<flag>              Display the setting of a command line option.
+  __<name>             Display the setting of an option, by name.
+  +cmd                 Execute the less cmd each time a new file is examined.
+  !command             Execute the shell command with $SHELL.
+  |Xcommand            Pipe file between current pos & mark X to shell command.
+  v                    Edit the current file with $VISUAL or $EDITOR.
+  V                    Print version number of "less".
+ ---------------------------------------------------------------------------
+                           OPTIONS
+        Most options may be changed either on the command line,
+        or from within less by using the - or -- command.
+        Options may be given in one of two forms: either a single
+        character preceded by a -, or a name preceeded by --.
+  -?  ........  --help
+                  Display help (from command line).
+  -a  ........  --search-skip-screen
+                  Forward search skips current screen.
+  -b [N]  ....  --buffers=[N]
+                  Number of buffers.
+  -B  ........  --auto-buffers
+                  Don't automatically allocate buffers for pipes.
+  -c  ........  --clear-screen
+                  Repaint by clearing rather than scrolling.
+  -d  ........  --dumb
+                  Dumb terminal.
+  -D [xn.n]  .  --color=xn.n
+                  Set screen colors. (MS-DOS only)
+  -e  -E  ....  --quit-at-eof  --QUIT-AT-EOF
+                  Quit at end of file.
+  -f  ........  --force
+                  Force open non-regular files.
+  -F  ........  --quit-if-one-screen
+                  Quit if entire file fits on first screen.
+  -g  ........  --hilite-search
+                  Highlight only last match for searches.
+  -G  ........  --HILITE-SEARCH
+                  Don't highlight any matches for searches.
+  -h [N]  ....  --max-back-scroll=[N]
+                  Backward scroll limit.
+  -i  ........  --ignore-case
+                  Ignore case in searches that do not contain uppercase.
+  -I  ........  --IGNORE-CASE
+                  Ignore case in all searches.
+  -j [N]  ....  --jump-target=[N]
+                  Screen position of target lines.
+  -J  ........  --status-column
+                  Display a status column at left edge of screen.
+  -k [file]  .  --lesskey-file=[file]
+                  Use a lesskey file.
+  -L  ........  --no-lessopen
+                  Ignore the LESSOPEN environment variable.
+  -m  -M  ....  --long-prompt  --LONG-PROMPT
+                  Set prompt style.
+  -n  -N  ....  --line-numbers  --LINE-NUMBERS
+                  Don't use line numbers.
+  -o [file]  .  --log-file=[file]
+                  Copy to log file (standard input only).
+  -O [file]  .  --LOG-FILE=[file]
+                  Copy to log file (unconditionally overwrite).
+  -p [pattern]  --pattern=[pattern]
+                  Start at pattern (from command line).
+  -P [prompt]   --prompt=[prompt]
+                  Define new prompt.
+  -q  -Q  ....  --quiet  --QUIET  --silent --SILENT
+                  Quiet the terminal bell.
+  -r  -R  ....  --raw-control-chars  --RAW-CONTROL-CHARS
+                  Output "raw" control characters.
+  -s  ........  --squeeze-blank-lines
+                  Squeeze multiple blank lines.
+  -S  ........  --chop-long-lines
+                  Chop long lines.
+  -t [tag]  ..  --tag=[tag]
+                  Find a tag.
+  -T [tagsfile] --tag-file=[tagsfile]
+                  Use an alternate tags file.
+  -u  -U  ....  --underline-special  --UNDERLINE-SPECIAL
+                  Change handling of backspaces.
+  -V  ........  --version
+                  Display the version number of "less".
+  -w  ........  --hilite-unread
+                  Highlight first new line after forward-screen.
+  -W  ........  --HILITE-UNREAD
+                  Highlight first new line after any forward movement.
+  -x [N[,...]]  --tabs=[N[,...]]
+                  Set tab stops.
+  -X  ........  --no-init
+                  Don't use termcap init/deinit strings.
+                --no-keypad
+                  Don't use termcap keypad init/deinit strings.
+  -y [N]  ....  --max-forw-scroll=[N]
+                  Forward scroll limit.
+  -z [N]  ....  --window=[N]
+                  Set size of window.
+  -" [c[c]]  .  --quotes=[c[c]]
+                  Set shell quote characters.
+  -~  ........  --tilde
+                  Don't display tildes after end of file.
+  -# [N]  ....  --shift=[N]
+                  Horizontal scroll amount (0 = one half screen width)
+
+ ---------------------------------------------------------------------------
+                          LINE EDITING
+        These keys can be used to edit text being entered
+        on the "command line" at the bottom of the screen.
+ RightArrow                       ESC-l     Move cursor right one character.
+ LeftArrow                        ESC-h     Move cursor left one character.
+ CNTL-RightArrow  ESC-RightArrow  ESC-w     Move cursor right one word.
+ CNTL-LeftArrow   ESC-LeftArrow   ESC-b     Move cursor left one word.
+ HOME                             ESC-0     Move cursor to start of line.
+ END                              ESC-$     Move cursor to end of line.
+ BACKSPACE                                  Delete char to left of cursor.
+ DELETE                           ESC-x     Delete char under cursor.
+ CNTL-BACKSPACE   ESC-BACKSPACE             Delete word to left of cursor.
+ CNTL-DELETE      ESC-DELETE      ESC-X     Delete word under cursor.
+ CNTL-U           ESC (MS-DOS only)         Delete entire line.
+ UpArrow                          ESC-k     Retrieve previous command line.
+ DownArrow                        ESC-j     Retrieve next command line.
+ TAB                                        Complete filename & cycle.
+ SHIFT-TAB                        ESC-TAB   Complete filename & reverse cycle.
+ CNTL-L                                     Complete filename, list all.
+*/

branches/2.2.9/mindi-busybox/miscutils/makedevs.c

@@ -11 +11 @@
 
 #if ENABLE_FEATURE_MAKEDEVS_LEAF
-int makedevs_main(int argc, char **argv);
+/*
+makedevs NAME TYPE MAJOR MINOR FIRST LAST [s]
+TYPEs:
+b       Block device
+c       Character device
+f       FIFO
+
+FIRST..LAST specify numbers appended to NAME.
+If 's' is the last argument, the base device is created as well.
+Examples:
+        makedevs /dev/ttyS c 4 66 2 63   ->  ttyS2-ttyS63
+        makedevs /dev/hda b 3 0 0 8 s    ->  hda,hda1-hda8
+*/
+int makedevs_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int makedevs_main(int argc, char **argv)
 {
     mode_t mode;
-    char *basedev, *type, *nodname, buf[255];
+    char *basedev, *type, *nodname, *buf;
     int Smajor, Sminor, S, E;
 
-    if (argc < 7 || *argv[1]=='-')
+    if (argc < 7 || argv[1][0] == '-')
         bb_show_usage();
 
     basedev = argv[1];
+    buf = xasprintf("%s%u", argv[1], (unsigned)-1);
     type = argv[2];
-    Smajor = xatoi_u(argv[3]);
-    Sminor = xatoi_u(argv[4]);
-    S = xatoi_u(argv[5]);
-    E = xatoi_u(argv[6]);
-    nodname = argc == 8 ? basedev : buf;
+    Smajor = xatoi_positive(argv[3]);
+    Sminor = xatoi_positive(argv[4]);
+    S = xatoi_positive(argv[5]);
+    E = xatoi_positive(argv[6]);
+    nodname = argv[7] ? basedev : buf;
 
     mode = 0660;
-
     switch (type[0]) {
     case 'c':
@@ -46 +59 @@
 
     while (S <= E) {
-        int sz;
-
-        sz = snprintf(buf, sizeof(buf), "%s%d", basedev, S);
-        if (sz < 0 || sz >= sizeof(buf))  /* libc different */
-            bb_error_msg_and_die("%s too large", basedev);
-
-    /* if mode != S_IFCHR and != S_IFBLK third param in mknod() ignored */
-
+        sprintf(buf, "%s%u", basedev, S);
+
+        /* if mode != S_IFCHR and != S_IFBLK,
+         * third param in mknod() ignored */
         if (mknod(nodname, mode, makedev(Smajor, Sminor)))
-            bb_error_msg("failed to create: %s", nodname);
-
-        if (nodname == basedev) /* ex. /dev/hda - to /dev/hda1 ... */
+            bb_perror_msg("can't create '%s'", nodname);
+
+        /*if (nodname == basedev)*/ /* ex. /dev/hda - to /dev/hda1 ... */
             nodname = buf;
         S++;
@@ -68 +77 @@
 #elif ENABLE_FEATURE_MAKEDEVS_TABLE
 
-/* Licensed under the GPL v2 or later, see the file LICENSE in this tarball. */
-
-int makedevs_main(int argc, char **argv);
-int makedevs_main(int argc, char **argv)
+/* Licensed under GPLv2 or later, see file LICENSE in this source tree. */
+
+int makedevs_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int makedevs_main(int argc UNUSED_PARAM, char **argv)
 {
-    FILE *table = stdin;
-    char *rootdir = NULL;
-    char *line = NULL;
-    int linenum = 0;
+    parser_t *parser;
+    char *line = (char *)"-";
     int ret = EXIT_SUCCESS;
 
+    opt_complementary = "=1"; /* exactly one param */
     getopt32(argv, "d:", &line);
-    if (line)
-        table = xfopen(line, "r");
-
-    if (optind >= argc || (rootdir=argv[optind])==NULL) {
-        bb_error_msg_and_die("root directory not specified");
-    }
-
-    xchdir(rootdir);
+    argv += optind;
+
+    xchdir(*argv); /* ensure root dir exists */
 
     umask(0);
 
-    printf("rootdir=%s\n", rootdir);
-    if (line) {
-        printf("table='%s'\n", line);
+    printf("rootdir=%s\ntable=", *argv);
+    if (NOT_LONE_DASH(line)) {
+        printf("'%s'\n", line);
     } else {
-        printf("table=<stdin>\n");
-    }
-
-    while ((line = xmalloc_getline(table))) {
+        puts("<stdin>");
+    }
+
+    parser = config_open(line);
+    while (config_read(parser, &line, 1, 1, "# \t", PARSE_NORMAL)) {
+        int linenum;
         char type;
-        unsigned int mode = 0755;
-        unsigned int major = 0;
-        unsigned int minor = 0;
-        unsigned int count = 0;
-        unsigned int increment = 0;
-        unsigned int start = 0;
+        unsigned mode = 0755;
+        unsigned major = 0;
+        unsigned minor = 0;
+        unsigned count = 0;
+        unsigned increment = 0;
+        unsigned start = 0;
         char name[41];
         char user[41];
         char group[41];
-        char *full_name;
+        char *full_name = name;
         uid_t uid;
         gid_t gid;
 
-        linenum++;
-
-        if ((2 > sscanf(line, "%40s %c %o %40s %40s %u %u %u %u %u", name,
-                        &type, &mode, user, group, &major,
-                        &minor, &start, &increment, &count)) ||
-                ((major | minor | start | count | increment) > 255))
-        {
-            if (*line=='\0' || *line=='#' || isspace(*line))
-                continue;
-            bb_error_msg("line %d invalid: '%s'", linenum, line);
+        linenum = parser->lineno;
+
+        if ((2 > sscanf(line, "%40s %c %o %40s %40s %u %u %u %u %u",
+                    name, &type, &mode, user, group,
+                    &major, &minor, &start, &increment, &count))
+         || ((unsigned)(major | minor | start | count | increment) > 255)
+        ) {
+            bb_error_msg("invalid line %d: '%s'", linenum, line);
             ret = EXIT_FAILURE;
             continue;
         }
-        if (name[0] == '#') {
-            continue;
-        }
 
         gid = (*group) ? get_ug_id(group, xgroup2gid) : getgid();
         uid = (*user) ? get_ug_id(user, xuname2uid) : getuid();
-        full_name = concat_path_file(rootdir, name);
+        /* We are already in the right root dir,
+         * so make absolute paths relative */
+        if ('/' == *full_name)
+            full_name++;
 
         if (type == 'd') {
             bb_make_directory(full_name, mode | S_IFDIR, FILEUTILS_RECUR);
             if (chown(full_name, uid, gid) == -1) {
-                bb_perror_msg("line %d: chown failed for %s", linenum, full_name);
-                ret = EXIT_FAILURE;
-                goto loop;
-            }
-            if ((mode != -1) && (chmod(full_name, mode) < 0)){
-                bb_perror_msg("line %d: chmod failed for %s", linenum, full_name);
-                ret = EXIT_FAILURE;
-                goto loop;
+ chown_fail:
+                bb_perror_msg("line %d: can't chown %s", linenum, full_name);
+                ret = EXIT_FAILURE;
+                continue;
+            }
+            if (chmod(full_name, mode) < 0) {
+ chmod_fail:
+                bb_perror_msg("line %d: can't chmod %s", linenum, full_name);
+                ret = EXIT_FAILURE;
+                continue;
             }
         } else if (type == 'f') {
@@ -151 +156 @@
                 bb_perror_msg("line %d: regular file '%s' does not exist", linenum, full_name);
                 ret = EXIT_FAILURE;
-                goto loop;
-            }
-            if (chown(full_name, uid, gid) == -1) {
-                bb_perror_msg("line %d: chown failed for %s", linenum, full_name);
-                ret = EXIT_FAILURE;
-                goto loop;
-            }
-            if ((mode != -1) && (chmod(full_name, mode) < 0)){
-                bb_perror_msg("line %d: chmod failed for %s", linenum, full_name);
-                ret = EXIT_FAILURE;
-                goto loop;
-            }
+                continue;
+            }
+            if (chown(full_name, uid, gid) < 0)
+                goto chown_fail;
+            if (chmod(full_name, mode) < 0)
+                goto chmod_fail;
         } else {
             dev_t rdev;
+            unsigned i;
+            char *full_name_inc;
 
             if (type == 'p') {
                 mode |= S_IFIFO;
-            }
-            else if (type == 'c') {
+            } else if (type == 'c') {
                 mode |= S_IFCHR;
-            }
-            else if (type == 'b') {
+            } else if (type == 'b') {
                 mode |= S_IFBLK;
             } else {
                 bb_error_msg("line %d: unsupported file type %c", linenum, type);
                 ret = EXIT_FAILURE;
-                goto loop;
-            }
-
-            if (count > 0) {
-                int i;
-                char *full_name_inc;
-
-                full_name_inc = xmalloc(strlen(full_name) + 4);
-                for (i = start; i < count; i++) {
-                    sprintf(full_name_inc, "%s%d", full_name, i);
-                    rdev = makedev(major, minor + (i * increment - start));
-                    if (mknod(full_name_inc, mode, rdev) == -1) {
-                        bb_perror_msg("line %d: cannot create node %s", linenum, full_name_inc);
-                        ret = EXIT_FAILURE;
-                    }
-                    else if (chown(full_name_inc, uid, gid) == -1) {
-                        bb_perror_msg("line %d: chown failed for %s", linenum, full_name_inc);
-                        ret = EXIT_FAILURE;
-                    }
-                    if ((mode != -1) && (chmod(full_name_inc, mode) < 0)){
-                        bb_perror_msg("line %d: chmod failed for %s", linenum, full_name_inc);
-                        ret = EXIT_FAILURE;
-                    }
-                }
-                free(full_name_inc);
-            } else {
-                rdev = makedev(major, minor);
-                if (mknod(full_name, mode, rdev) == -1) {
-                    bb_perror_msg("line %d: cannot create node %s", linenum, full_name);
+                continue;
+            }
+
+            full_name_inc = xmalloc(strlen(full_name) + sizeof(int)*3 + 2);
+            if (count)
+                count--;
+            for (i = start; i <= start + count; i++) {
+                sprintf(full_name_inc, count ? "%s%u" : "%s", full_name, i);
+                rdev = makedev(major, minor + (i - start) * increment);
+                if (mknod(full_name_inc, mode, rdev) < 0) {
+                    bb_perror_msg("line %d: can't create node %s", linenum, full_name_inc);
+                    ret = EXIT_FAILURE;
+                } else if (chown(full_name_inc, uid, gid) < 0) {
+                    bb_perror_msg("line %d: can't chown %s", linenum, full_name_inc);
+                    ret = EXIT_FAILURE;
+                } else if (chmod(full_name_inc, mode) < 0) {
+                    bb_perror_msg("line %d: can't chmod %s", linenum, full_name_inc);
                     ret = EXIT_FAILURE;
                 }
-                else if (chown(full_name, uid, gid) == -1) {
-                    bb_perror_msg("line %d: chown failed for %s", linenum, full_name);
-                    ret = EXIT_FAILURE;
-                }
-                if ((mode != -1) && (chmod(full_name, mode) < 0)){
-                    bb_perror_msg("line %d: chmod failed for %s", linenum, full_name);
-                    ret = EXIT_FAILURE;
-                }
-            }
+            }
+            free(full_name_inc);
         }
-loop:
-        free(line);
-        free(full_name);
-    }
-    fclose(table);
+    }
+    if (ENABLE_FEATURE_CLEAN_UP)
+        config_close(parser);
 
     return ret;

branches/2.2.9/mindi-busybox/miscutils/mountpoint.c

@@ -3 +3 @@
  * mountpoint implementation for busybox
  *
- * Copyright (C) 2005 Bernhard Fischer
+ * Copyright (C) 2005 Bernhard Reutner-Fischer
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
  * Based on sysvinit's mountpoint
@@ -12 +12 @@
 #include "libbb.h"
 
-int mountpoint_main(int argc, char **argv);
-int mountpoint_main(int argc, char **argv)
+int mountpoint_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int mountpoint_main(int argc UNUSED_PARAM, char **argv)
 {
     struct stat st;
+    const char *msg;
     char *arg;
-    int opt = getopt32(argv, "qdx");
+    int rc, opt;
+
+    opt_complementary = "=1"; /* must have one argument */
+    opt = getopt32(argv, "qdxn");
 #define OPT_q (1)
 #define OPT_d (2)
 #define OPT_x (4)
+#define OPT_n (8)
+    arg = argv[optind];
+    msg = "%s";
 
-    if (optind != argc - 1)
-        bb_show_usage();
+    rc = (opt & OPT_x) ? stat(arg, &st) : lstat(arg, &st);
+    if (rc != 0)
+        goto err;
 
-    arg = argv[optind];
+    if (opt & OPT_x) {
+        if (S_ISBLK(st.st_mode)) {
+            printf("%u:%u\n", major(st.st_rdev),
+                        minor(st.st_rdev));
+            return EXIT_SUCCESS;
+        }
+        errno = 0; /* make perror_msg work as error_msg */
+        msg = "%s: not a block device";
+        goto err;
+    }
 
-    if ( (opt & OPT_x && stat(arg, &st) == 0) || (lstat(arg, &st) == 0) ) {
-        if (opt & OPT_x) {
-            if (S_ISBLK(st.st_mode)) {
-                printf("%u:%u\n", major(st.st_rdev),
-                            minor(st.st_rdev));
-                return EXIT_SUCCESS;
-            } else {
-                if (opt & OPT_q)
-                    putchar('\n');
-                else
-                    bb_error_msg("%s: not a block device", arg);
+    errno = ENOTDIR;
+    if (S_ISDIR(st.st_mode)) {
+        dev_t st_dev = st.st_dev;
+        ino_t st_ino = st.st_ino;
+        char *p = xasprintf("%s/..", arg);
+
+        if (stat(p, &st) == 0) {
+            //int is_mnt = (st_dev != st.st_dev) || (st_dev == st.st_dev && st_ino == st.st_ino);
+            int is_not_mnt = (st_dev == st.st_dev) && (st_ino != st.st_ino);
+
+            if (opt & OPT_d)
+                printf("%u:%u\n", major(st_dev), minor(st_dev));
+            if (opt & OPT_n) {
+                const char *d = find_block_device(arg);
+                /* name is undefined, but device is mounted -> anonymous superblock! */
+                /* happens with btrfs */
+                if (!d) {
+                    d = "UNKNOWN";
+                    /* TODO: iterate /proc/mounts, or /proc/self/mountinfo
+                     * to find out the device name */
+                }
+                printf("%s %s\n", d, arg);
             }
-            return EXIT_FAILURE;
-        } else
-        if (S_ISDIR(st.st_mode)) {
-            dev_t st_dev = st.st_dev;
-            ino_t st_ino = st.st_ino;
-            char *p = xasprintf("%s/..", arg);
+            if (!(opt & (OPT_q | OPT_d | OPT_n)))
+                printf("%s is %sa mountpoint\n", arg, is_not_mnt ? "not " : "");
+            return is_not_mnt;
+        }
+        arg = p;
+        /* else: stat had set errno, just fall through */
+    }
 
-            if (stat(p, &st) == 0) {
-                int ret = (st_dev != st.st_dev) ||
-                    (st_dev == st.st_dev && st_ino == st.st_ino);
-                if (opt & OPT_d)
-                    printf("%u:%u\n", major(st_dev), minor(st_dev));
-                else if (!(opt & OPT_q))
-                    printf("%s is %sa mountpoint\n", arg, ret?"":"not ");
-                return !ret;
-            }
-        } else {
-            if (!(opt & OPT_q))
-                bb_error_msg("%s: not a directory", arg);
-            return EXIT_FAILURE;
-        }
-    }
+ err:
     if (!(opt & OPT_q))
-        bb_perror_msg("%s", arg);
+        bb_perror_msg(msg, arg);
     return EXIT_FAILURE;
 }

branches/2.2.9/mindi-busybox/miscutils/mt.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -7 +7 @@
 #include <sys/mtio.h>
 
-struct mt_opcodes {
-    const char *name;
-    short value;
+/* missing: eod/seod, stoptions, stwrthreshold, densities */
+static const short opcode_value[] = {
+    MTBSF,
+    MTBSFM,
+    MTBSR,
+    MTBSS,
+    MTCOMPRESSION,
+    MTEOM,
+    MTERASE,
+    MTFSF,
+    MTFSFM,
+    MTFSR,
+    MTFSS,
+    MTLOAD,
+    MTLOCK,
+    MTMKPART,
+    MTNOP,
+    MTOFFL,
+    MTOFFL,
+    MTRAS1,
+    MTRAS2,
+    MTRAS3,
+    MTRESET,
+    MTRETEN,
+    MTREW,
+    MTSEEK,
+    MTSETBLK,
+    MTSETDENSITY,
+    MTSETDRVBUFFER,
+    MTSETPART,
+    MTTELL,
+    MTWSM,
+    MTUNLOAD,
+    MTUNLOCK,
+    MTWEOF,
+    MTWEOF
 };
 
-/* missing: eod/seod, stoptions, stwrthreshold, densities */
-static const struct mt_opcodes opcodes[] = {
-    {"bsf", MTBSF},
-    {"bsfm", MTBSFM},
-    {"bsr", MTBSR},
-    {"bss", MTBSS},
-    {"datacompression", MTCOMPRESSION},
-    {"eom", MTEOM},
-    {"erase", MTERASE},
-    {"fsf", MTFSF},
-    {"fsfm", MTFSFM},
-    {"fsr", MTFSR},
-    {"fss", MTFSS},
-    {"load", MTLOAD},
-    {"lock", MTLOCK},
-    {"mkpart", MTMKPART},
-    {"nop", MTNOP},
-    {"offline", MTOFFL},
-    {"rewoffline", MTOFFL},
-    {"ras1", MTRAS1},
-    {"ras2", MTRAS2},
-    {"ras3", MTRAS3},
-    {"reset", MTRESET},
-    {"retension", MTRETEN},
-    {"rewind", MTREW},
-    {"seek", MTSEEK},
-    {"setblk", MTSETBLK},
-    {"setdensity", MTSETDENSITY},
-    {"drvbuffer", MTSETDRVBUFFER},
-    {"setpart", MTSETPART},
-    {"tell", MTTELL},
-    {"wset", MTWSM},
-    {"unload", MTUNLOAD},
-    {"unlock", MTUNLOCK},
-    {"eof", MTWEOF},
-    {"weof", MTWEOF},
-    {0, 0}
-};
+static const char opcode_name[] ALIGN1 =
+    "bsf"             "\0"
+    "bsfm"            "\0"
+    "bsr"             "\0"
+    "bss"             "\0"
+    "datacompression" "\0"
+    "eom"             "\0"
+    "erase"           "\0"
+    "fsf"             "\0"
+    "fsfm"            "\0"
+    "fsr"             "\0"
+    "fss"             "\0"
+    "load"            "\0"
+    "lock"            "\0"
+    "mkpart"          "\0"
+    "nop"             "\0"
+    "offline"         "\0"
+    "rewoffline"      "\0"
+    "ras1"            "\0"
+    "ras2"            "\0"
+    "ras3"            "\0"
+    "reset"           "\0"
+    "retension"       "\0"
+    "rewind"          "\0"
+    "seek"            "\0"
+    "setblk"          "\0"
+    "setdensity"      "\0"
+    "drvbuffer"       "\0"
+    "setpart"         "\0"
+    "tell"            "\0"
+    "wset"            "\0"
+    "unload"          "\0"
+    "unlock"          "\0"
+    "eof"             "\0"
+    "weof"            "\0";
 
-int mt_main(int argc, char **argv);
-int mt_main(int argc, char **argv)
+int mt_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int mt_main(int argc UNUSED_PARAM, char **argv)
 {
     const char *file = "/dev/tape";
-    const struct mt_opcodes *code = opcodes;
     struct mtop op;
     struct mtpos position;
-    int fd, mode;
+    int fd, mode, idx;
 
-    if (argc < 2) {
+    if (!argv[1]) {
         bb_show_usage();
     }
 
     if (strcmp(argv[1], "-f") == 0) {
-        if (argc < 4) {
+        if (!argv[2] || !argv[3])
             bb_show_usage();
-        }
         file = argv[2];
         argv += 2;
-        argc -= 2;
     }
 
-    while (code->name != 0) {
-        if (strcmp(code->name, argv[1]) == 0)
-            break;
-        code++;
-    }
+    idx = index_in_strings(opcode_name, argv[1]);
 
-    if (code->name == 0) {
-        bb_error_msg("unrecognized opcode %s", argv[1]);
-        return EXIT_FAILURE;
-    }
+    if (idx < 0)
+        bb_error_msg_and_die("unrecognized opcode %s", argv[1]);
 
-    op.mt_op = code->value;
-    if (argc >= 3)
-        op.mt_count = xatoi_u(argv[2]);
+    op.mt_op = opcode_value[idx];
+    if (argv[2])
+        op.mt_count = xatoi_positive(argv[2]);
     else
-        op.mt_count = 1;        /* One, not zero, right? */
+        op.mt_count = 1;  /* One, not zero, right? */
 
-    switch (code->value) {
+    switch (opcode_value[idx]) {
         case MTWEOF:
         case MTERASE:
@@ -105 +126 @@
     fd = xopen(file, mode);
 
-    switch (code->value) {
+    switch (opcode_value[idx]) {
         case MTTELL:
             ioctl_or_perror_and_die(fd, MTIOCPOS, &position, "%s", file);
-            printf("At block %d.\n", (int) position.mt_blkno);
+            printf("At block %d\n", (int) position.mt_blkno);
             break;
 

branches/2.2.9/mindi-busybox/miscutils/raidautorun.c

@@ -3 +3 @@
  * raidautorun implementation for busybox
  *
- * Copyright (C) 2006 Bernhard Fischer
+ * Copyright (C) 2006 Bernhard Reutner-Fischer
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
  */
@@ -14 +14 @@
 #include <linux/raid/md_u.h>
 
-int raidautorun_main(int argc, char **argv);
-int raidautorun_main(int argc, char **argv)
+int raidautorun_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int raidautorun_main(int argc UNUSED_PARAM, char **argv)
 {
-    if (argc != 2)
-        bb_show_usage();
-
-    xioctl(xopen(argv[1], O_RDONLY), RAID_AUTORUN, NULL);
-
+    xioctl(xopen(single_argv(argv), O_RDONLY), RAID_AUTORUN, NULL);
     return EXIT_SUCCESS;
 }

branches/2.2.9/mindi-busybox/miscutils/readahead.c

@@ -8 +8 @@
  * Copyright (C) 2006  Michael Opdenacker <michael@free-electrons.com>
  *
- * Licensed under GPLv2 or later, see file License in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
 #include "libbb.h"
 
-int readahead_main(int argc, char **argv);
-int readahead_main(int argc, char **argv)
+int readahead_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int readahead_main(int argc UNUSED_PARAM, char **argv)
 {
-    FILE *f;
     int retval = EXIT_SUCCESS;
 
-    if (argc == 1) bb_show_usage();
+    if (!argv[1]) {
+        bb_show_usage();
+    }
 
     while (*++argv) {
-        if ((f = fopen_or_warn(*argv, "r")) != NULL) {
-            int r, fd=fileno(f);
+        int fd = open_or_warn(*argv, O_RDONLY);
+        if (fd >= 0) {
+            off_t len;
+            int r;
 
-            r = readahead(fd, 0, fdlength(fd));
-            fclose(f);
-            if (r >= 0) continue;
+            /* fdlength was reported to be unreliable - use seek */
+            len = xlseek(fd, 0, SEEK_END);
+            xlseek(fd, 0, SEEK_SET);
+            r = readahead(fd, 0, len);
+            close(fd);
+            if (r >= 0)
+                continue;
         }
         retval = EXIT_FAILURE;

branches/2.2.9/mindi-busybox/miscutils/runlevel.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
 /*
- * runlevel Prints out the previous and the current runlevel.
+ * Prints out the previous and the current runlevel.
  *
- * Version: @(#)runlevel  1.20  16-Apr-1997  MvS
+ * Version: @(#)runlevel  1.20  16-Apr-1997  MvS
  *
- *      This file is part of the sysvinit suite,
- *      Copyright 1991-1997 Miquel van Smoorenburg.
+ * This file is part of the sysvinit suite,
+ * Copyright 1991-1997 Miquel van Smoorenburg.
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
- * initially busyboxified by Bernhard Fischer
+ * initially busyboxified by Bernhard Reutner-Fischer
  */
+#include "libbb.h"
+#include <utmp.h>
 
-#include <utmp.h>
-#include "libbb.h"
-
-int runlevel_main(int argc, char **argv);
-int runlevel_main(int argc, char **argv)
+int runlevel_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int runlevel_main(int argc UNUSED_PARAM, char **argv)
 {
     struct utmp *ut;
     char prev;
 
-    if (argc > 1) utmpname(argv[1]);
+    if (argv[1]) utmpname(argv[1]);
 
     setutent();

branches/2.2.9/mindi-busybox/miscutils/rx.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-/*-------------------------------------------------------------------------
- * Filename:      xmodem.c
+/*
  * Copyright:     Copyright (C) 2001, Hewlett-Packard Company
  * Author:        Christopher Hoover <ch@hpl.hp.com>
@@ -7 +6 @@
  *                and the like
  * Created at:    Thu Dec 20 01:58:08 PST 2001
- *-----------------------------------------------------------------------*/
-/*
- * xmodem.c: xmodem functionality for uploading of kernels and
- *            the like
+ *
+ * xmodem functionality for uploading of kernels and the like
  *
  * Copyright (C) 2001 Hewlett-Packard Laboratories
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  *
  * This was originally written for blob and then adapted for busybox.
- *
  */
 
@@ -28 +24 @@
 #define NAK 0x15
 #define BS  0x08
+#define PAD 0x1A
 
 /*
-
 Cf:
-
   http://www.textfiles.com/apple/xmodem
   http://www.phys.washington.edu/~belonis/xmodem/docxmodem.txt
   http://www.phys.washington.edu/~belonis/xmodem/docymodem.txt
   http://www.phys.washington.edu/~belonis/xmodem/modmprot.col
-
 */
 
@@ -44 +38 @@
 #define MAXERRORS 10
 
-static int read_byte(int fd, unsigned int timeout)
-{
-    char buf[1];
+#define read_fd  STDIN_FILENO
+#define write_fd STDOUT_FILENO
+
+static int read_byte(unsigned timeout)
+{
+    unsigned char buf;
     int n;
 
     alarm(timeout);
-
-    n = read(fd, &buf, 1);
-
+    /* NOT safe_read! We want ALRM to interrupt us */
+    n = read(read_fd, &buf, 1);
     alarm(0);
-
     if (n == 1)
-        return buf[0] & 0xff;
-    else
-        return -1;
-}
-
-static int receive(char *error_buf, size_t error_buf_size,
-                   int ttyfd, int filefd)
-{
-    char blockBuf[1024];
-    unsigned int errors = 0;
-    unsigned int wantBlockNo = 1;
-    unsigned int length = 0;
-    int docrc = 1;
-    char nak = 'C';
-    unsigned int timeout = TIMEOUT_LONG;
-
-#define note_error(fmt,args...) \
-    snprintf(error_buf, error_buf_size, fmt,##args)
+        return buf;
+    return -1;
+}
+
+static int receive(/*int read_fd, */int file_fd)
+{
+    unsigned char blockBuf[1024];
+    unsigned blockLength = 0;
+    unsigned errors = 0;
+    unsigned wantBlockNo = 1;
+    unsigned length = 0;
+    int do_crc = 1;
+    char reply_char;
+    unsigned timeout = TIMEOUT_LONG;
 
     /* Flush pending input */
-    tcflush(ttyfd, TCIFLUSH);
+    tcflush(read_fd, TCIFLUSH);
 
     /* Ask for CRC; if we get errors, we will go with checksum */
-    write(ttyfd, &nak, 1);
+    reply_char = 'C';
+    full_write(write_fd, &reply_char, 1);
 
     for (;;) {
         int blockBegin;
         int blockNo, blockNoOnesCompl;
-        int blockLength;
-        int cksum = 0;
-        int crcHi = 0;
-        int crcLo = 0;
-
-        blockBegin = read_byte(ttyfd, timeout);
+        int cksum_or_crc;
+        int expected;
+        int i, j;
+
+        blockBegin = read_byte(timeout);
         if (blockBegin < 0)
             goto timeout;
 
+        /* If last block, remove padding */
+        if (blockBegin == EOT) {
+            /* Data blocks can be padded with ^Z characters */
+            /* This code tries to detect and remove them */
+            if (blockLength >= 3
+             && blockBuf[blockLength - 1] == PAD
+             && blockBuf[blockLength - 2] == PAD
+             && blockBuf[blockLength - 3] == PAD
+            ) {
+                while (blockLength
+                       && blockBuf[blockLength - 1] == PAD
+                ) {
+                    blockLength--;
+                }
+            }
+        }
+        /* Write previously received block */
+        if (blockLength) {
+            errno = 0;
+            if (full_write(file_fd, blockBuf, blockLength) != blockLength) {
+                bb_perror_msg("can't write to file");
+                goto fatal;
+            }
+        }
+
         timeout = TIMEOUT;
-        nak = NAK;
+        reply_char = NAK;
 
         switch (blockBegin) {
@@ -100 +116 @@
         case STX:
             break;
-
         case EOT:
-            nak = ACK;
-            write(ttyfd, &nak, 1);
-            goto done;
-
+            reply_char = ACK;
+            full_write(write_fd, &reply_char, 1);
+            return length;
         default:
             goto error;
         }
 
-        /* block no */
-        blockNo = read_byte(ttyfd, TIMEOUT);
+        /* Block no */
+        blockNo = read_byte(TIMEOUT);
         if (blockNo < 0)
             goto timeout;
 
-        /* block no one's compliment */
-        blockNoOnesCompl = read_byte(ttyfd, TIMEOUT);
+        /* Block no, in one's complement form */
+        blockNoOnesCompl = read_byte(TIMEOUT);
         if (blockNoOnesCompl < 0)
             goto timeout;
 
         if (blockNo != (255 - blockNoOnesCompl)) {
-            note_error("bad block ones compl");
+            bb_error_msg("bad block ones compl");
             goto error;
         }
@@ -127 +141 @@
         blockLength = (blockBegin == SOH) ? 128 : 1024;
 
-        {
-            int i;
-
-            for (i = 0; i < blockLength; i++) {
-                int cc = read_byte(ttyfd, TIMEOUT);
-                if (cc < 0)
-                    goto timeout;
-                blockBuf[i] = cc;
-            }
-        }
-
-        if (docrc) {
-            crcHi = read_byte(ttyfd, TIMEOUT);
-            if (crcHi < 0)
-                goto timeout;
-
-            crcLo = read_byte(ttyfd, TIMEOUT);
-            if (crcLo < 0)
+        for (i = 0; i < blockLength; i++) {
+            int cc = read_byte(TIMEOUT);
+            if (cc < 0)
+                goto timeout;
+            blockBuf[i] = cc;
+        }
+
+        if (do_crc) {
+            cksum_or_crc = read_byte(TIMEOUT);
+            if (cksum_or_crc < 0)
+                goto timeout;
+            cksum_or_crc = (cksum_or_crc << 8) | read_byte(TIMEOUT);
+            if (cksum_or_crc < 0)
                 goto timeout;
         } else {
-            cksum = read_byte(ttyfd, TIMEOUT);
-            if (cksum < 0)
+            cksum_or_crc = read_byte(TIMEOUT);
+            if (cksum_or_crc < 0)
                 goto timeout;
         }
@@ -157 +166 @@
             /* meta data. */
             goto next;
-        } else if (blockNo != (wantBlockNo & 0xff)) {
-            note_error("unexpected block no, 0x%08x, expecting 0x%08x", blockNo, wantBlockNo);
-            goto error;
-        }
-
-        if (docrc) {
-            int crc = 0;
-            int i, j;
-            int expectedCrcHi;
-            int expectedCrcLo;
-
+        }
+        if (blockNo != (wantBlockNo & 0xff)) {
+            bb_error_msg("unexpected block no, 0x%08x, expecting 0x%08x", blockNo, wantBlockNo);
+            goto error;
+        }
+
+        expected = 0;
+        if (do_crc) {
             for (i = 0; i < blockLength; i++) {
-                crc = crc ^ (int) blockBuf[i] << 8;
-                for (j = 0; j < 8; j++)
-                    if (crc & 0x8000)
-                        crc = crc << 1 ^ 0x1021;
+                expected = expected ^ blockBuf[i] << 8;
+                for (j = 0; j < 8; j++) {
+                    if (expected & 0x8000)
+                        expected = (expected << 1) ^ 0x1021;
                     else
-                        crc = crc << 1;
-            }
-
-            expectedCrcHi = (crc >> 8) & 0xff;
-            expectedCrcLo = crc & 0xff;
-
-            if ((crcHi != expectedCrcHi) ||
-                (crcLo != expectedCrcLo)) {
-                note_error("crc error, expected 0x%02x 0x%02x, got 0x%02x 0x%02x", expectedCrcHi, expectedCrcLo, crcHi, crcLo);
-                goto error;
-            }
+                        expected = (expected << 1);
+                }
+            }
+            expected &= 0xffff;
         } else {
-            unsigned char expectedCksum = 0;
-            int i;
-
             for (i = 0; i < blockLength; i++)
-                expectedCksum += blockBuf[i];
-
-            if (cksum != expectedCksum) {
-                note_error("checksum error, expected 0x%02x, got 0x%02x", expectedCksum, cksum);
-                goto error;
-            }
+                expected += blockBuf[i];
+            expected &= 0xff;
+        }
+        if (cksum_or_crc != expected) {
+            bb_error_msg(do_crc ? "crc error, expected 0x%04x, got 0x%04x"
+                               : "checksum error, expected 0x%02x, got 0x%02x",
+                    expected, cksum_or_crc);
+            goto error;
         }
 
         wantBlockNo++;
         length += blockLength;
-
-        if (full_write(filefd, blockBuf, blockLength) < 0) {
-            note_error("write to file failed: %m");
-            goto fatal;
-        }
-
-    next:
+ next:
         errors = 0;
-        nak = ACK;
-        write(ttyfd, &nak, 1);
+        reply_char = ACK;
+        full_write(write_fd, &reply_char, 1);
         continue;
-
-    error:
-    timeout:
+ error:
+ timeout:
         errors++;
         if (errors == MAXERRORS) {
             /* Abort */
 
-            // if using crc, try again w/o crc
-            if (nak == 'C') {
-                nak = NAK;
+            /* If were asking for crc, try again w/o crc */
+            if (reply_char == 'C') {
+                reply_char = NAK;
                 errors = 0;
-                docrc = 0;
-                goto timeout;
-            }
-
-            note_error("too many errors; giving up");
-
-        fatal:
-            /* 5 CAN followed by 5 BS */
-            write(ttyfd, "\030\030\030\030\030\010\010\010\010\010", 10);
+                do_crc = 0;
+                goto timeout;
+            }
+            bb_error_msg("too many errors; giving up");
+ fatal:
+            /* 5 CAN followed by 5 BS. Don't try too hard... */
+            safe_write(write_fd, "\030\030\030\030\030\010\010\010\010\010", 10);
             return -1;
         }
 
         /* Flush pending input */
-        tcflush(ttyfd, TCIFLUSH);
-
-        write(ttyfd, &nak, 1);
+        tcflush(read_fd, TCIFLUSH);
+
+        full_write(write_fd, &reply_char, 1);
+    } /* for (;;) */
+}
+
+static void sigalrm_handler(int UNUSED_PARAM signum)
+{
+}
+
+int rx_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int rx_main(int argc UNUSED_PARAM, char **argv)
+{
+    struct termios tty, orig_tty;
+    int termios_err;
+    int file_fd;
+    int n;
+
+    /* Disabled by vda:
+     * why we can't receive from stdin? Why we *require*
+     * controlling tty?? */
+    /*read_fd = xopen(CURRENT_TTY, O_RDWR);*/
+    file_fd = xopen(single_argv(argv), O_RDWR|O_CREAT|O_TRUNC);
+
+    termios_err = tcgetattr(read_fd, &tty);
+    if (termios_err == 0) {
+        orig_tty = tty;
+        cfmakeraw(&tty);
+        tcsetattr(read_fd, TCSAFLUSH, &tty);
     }
 
- done:
-    return length;
-
-#undef note_error
-}
-
-static void sigalrm_handler(int ATTRIBUTE_UNUSED signum)
-{
-}
-
-int rx_main(int argc, char **argv);
-int rx_main(int argc, char **argv)
-{
-    char *fn;
-    int ttyfd, filefd;
-    struct termios tty, orig_tty;
-    struct sigaction act;
-    int n;
-    char error_buf[256];
-
-    if (argc != 2)
-            bb_show_usage();
-
-    fn = argv[1];
-    ttyfd = xopen(CURRENT_TTY, O_RDWR);
-    filefd = xopen(fn, O_RDWR|O_CREAT|O_TRUNC);
-
-    if (tcgetattr(ttyfd, &tty) < 0)
-            bb_perror_msg_and_die("tcgetattr");
-
-    orig_tty = tty;
-
-    cfmakeraw(&tty);
-    tcsetattr(ttyfd, TCSAFLUSH, &tty);
-
-    memset(&act, 0, sizeof(act));
-    act.sa_handler = sigalrm_handler;
-    sigaction(SIGALRM, &act, 0);
-
-    n = receive(error_buf, sizeof(error_buf), ttyfd, filefd);
-
-    close(filefd);
-
-    tcsetattr(ttyfd, TCSAFLUSH, &orig_tty);
-
-    if (n < 0)
-        bb_error_msg_and_die("\nreceive failed:\n  %s", error_buf);
-
-    fflush_stdout_and_exit(EXIT_SUCCESS);
-}
+    /* No SA_RESTART: we want ALRM to interrupt read() */
+    signal_no_SA_RESTART_empty_mask(SIGALRM, sigalrm_handler);
+
+    n = receive(file_fd);
+
+    if (termios_err == 0)
+        tcsetattr(read_fd, TCSAFLUSH, &orig_tty);
+    if (ENABLE_FEATURE_CLEAN_UP)
+        close(file_fd);
+    fflush_stdout_and_exit(n >= 0);
+}

branches/2.2.9/mindi-busybox/miscutils/setsid.c

@@ -5 +5 @@
  * In the public domain.
  *
- * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@pld.ORG.PL>
+ * 1999-02-22 Arkadiusz Mickiewicz <misiek@pld.ORG.PL>
  * - added Native Language Support
  *
@@ -17 +17 @@
 #include "libbb.h"
 
-int setsid_main(int argc, char **argv);
-int setsid_main(int argc, char **argv)
+int setsid_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int setsid_main(int argc UNUSED_PARAM, char **argv)
 {
-    if (argc < 2)
+    if (!argv[1])
         bb_show_usage();
 
-    /* Comment why is this necessary? */
-    if (getpgrp() == getpid())
-        forkexit_or_rexec(argv);
+    /* setsid() is allowed only when we are not a process group leader.
+     * Otherwise our PID serves as PGID of some existing process group
+     * and cannot be used as PGID of a new process group. */
+    if (setsid() < 0) {
+        pid_t pid = fork_or_rexec(argv);
+        if (pid != 0) {
+            /* parent */
+            /* TODO:
+             * we can waitpid(pid, &status, 0) and then even
+             * emulate exitcode, making the behavior consistent
+             * in both forked and non forked cases.
+             * However, the code is larger and upstream
+             * does not do such trick.
+             */
+            exit(EXIT_SUCCESS);
+        }
 
-    setsid();  /* no error possible */
+        /* child */
+        /* now there should be no error: */
+        setsid();
+    }
 
-    BB_EXECVP(argv[1], argv + 1);
-    bb_perror_msg_and_die("%s", argv[1]);
+    argv++;
+    BB_EXECVP_or_die(argv);
 }

branches/2.2.9/mindi-busybox/miscutils/strings.c

@@ -3 +3 @@
  * strings implementation for busybox
  *
- * Copyright Tito Ragusa <farmatito@tiscali.it>
+ * Copyright 2003 Tito Ragusa <farmatito@tiscali.it>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
-
-#include <getopt.h>
 
 #include "libbb.h"
 
-#define WHOLE_FILE      1
-#define PRINT_NAME      2
-#define PRINT_OFFSET    4
-#define SIZE            8
+#define WHOLE_FILE    1
+#define PRINT_NAME    2
+#define PRINT_OFFSET  4
+#define SIZE          8
 
-int strings_main(int argc, char **argv);
-int strings_main(int argc, char **argv)
+int strings_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int strings_main(int argc UNUSED_PARAM, char **argv)
 {
     int n, c, status = EXIT_SUCCESS;
-    unsigned opt;
     unsigned count;
     off_t offset;
-    FILE *file = stdin;
+    FILE *file;
     char *string;
     const char *fmt = "%s: ";
     const char *n_arg = "4";
 
-    opt = getopt32(argv, "afon:", &n_arg);
+    getopt32(argv, "afon:", &n_arg);
     /* -a is our default behaviour */
     /*argc -= optind;*/
@@ -41 +38 @@
         fmt = "{%s}: ";
         *--argv = (char *)bb_msg_standard_input;
-        goto PIPE;
     }
 
     do {
-        file = fopen_or_warn(*argv, "r");
+        file = fopen_or_warn_stdin(*argv);
         if (!file) {
             status = EXIT_FAILURE;
             continue;
         }
- PIPE:
         offset = 0;
         count = 0;
         do {
             c = fgetc(file);
-            if (isprint(c) || c == '\t') {
+            if (isprint_asciionly(c) || c == '\t') {
                 if (count > n) {
-                    putchar(c);
+                    bb_putchar(c);
                 } else {
                     string[count] = c;
                     if (count == n) {
-                        if (opt & PRINT_NAME) {
+                        if (option_mask32 & PRINT_NAME) {
                             printf(fmt, *argv);
                         }
-                        if (opt & PRINT_OFFSET) {
+                        if (option_mask32 & PRINT_OFFSET) {
                             printf("%7"OFF_FMT"o ", offset - n);
                         }
@@ -73 +68 @@
             } else {
                 if (count > n) {
-                    putchar('\n');
+                    bb_putchar('\n');
                 }
                 count = 0;

branches/2.2.9/mindi-busybox/miscutils/taskset.c

@@ -2 +2 @@
 /*
  * taskset - retrieve or set a processes' CPU affinity
- * Copyright (c) 2006 Bernhard Fischer
+ * Copyright (c) 2006 Bernhard Reutner-Fischer
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
 #include <sched.h>
-#include <getopt.h> /* optind */
 #include "libbb.h"
 
 #if ENABLE_FEATURE_TASKSET_FANCY
 #define TASKSET_PRINTF_MASK "%s"
-#define from_cpuset(x) __from_cpuset(&x)
 /* craft a string from the mask */
-static char *__from_cpuset(cpu_set_t *mask)
+static char *from_cpuset(cpu_set_t *mask)
 {
     int i;
-    char *ret = 0, *str = xzalloc(9);
+    char *ret = NULL;
+    char *str = xzalloc((CPU_SETSIZE / 4) + 1); /* we will leak it */
 
     for (i = CPU_SETSIZE - 4; i >= 0; i -= 4) {
-        char val = 0;
+        int val = 0;
         int off;
         for (off = 0; off <= 3; ++off)
-            if (CPU_ISSET(i+off, mask))
-                val |= 1<<off;
-
+            if (CPU_ISSET(i + off, mask))
+                val |= 1 << off;
         if (!ret && val)
             ret = str;
-        *str++ = (val-'0'<=9) ? (val+48) : (val+87);
+        *str++ = bb_hexdigits_upcase[val] | 0x20;
     }
     return ret;
 }
 #else
-#define TASKSET_PRINTF_MASK "%x"
-/* (void*) cast is for battling gcc: */
-/* "dereferencing type-punned pointer will break strict-aliasing rules" */
-#define from_cpuset(mask) (*(unsigned*)(void*)&(mask))
+#define TASKSET_PRINTF_MASK "%llx"
+static unsigned long long from_cpuset(cpu_set_t *mask)
+{
+    struct BUG_CPU_SETSIZE_is_too_small {
+        char BUG_CPU_SETSIZE_is_too_small[
+            CPU_SETSIZE < sizeof(int) ? -1 : 1];
+    };
+    char *p = (void*)mask;
+
+    /* Take the least significant bits. Careful!
+     * Consider both CPU_SETSIZE=4 and CPU_SETSIZE=1024 cases
+     */
+#if BB_BIG_ENDIAN
+    /* For big endian, it means LAST bits */
+    if (CPU_SETSIZE < sizeof(long))
+        p += CPU_SETSIZE - sizeof(int);
+    else if (CPU_SETSIZE < sizeof(long long))
+        p += CPU_SETSIZE - sizeof(long);
+    else
+        p += CPU_SETSIZE - sizeof(long long);
+#endif
+    if (CPU_SETSIZE < sizeof(long))
+        return *(unsigned*)p;
+    if (CPU_SETSIZE < sizeof(long long))
+        return *(unsigned long*)p;
+    return *(unsigned long long*)p;
+}
 #endif
 
-#define OPT_p 1
 
-int taskset_main(int argc, char** argv);
-int taskset_main(int argc, char** argv)
+int taskset_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int taskset_main(int argc UNUSED_PARAM, char **argv)
 {
-    cpu_set_t mask, new_mask;
+    cpu_set_t mask;
     pid_t pid = 0;
-    unsigned opt;
-    const char *state = "current\0new";
-    char *p_opt = NULL, *aff = NULL;
+    unsigned opt_p;
+    const char *current_new;
+    char *pid_str;
+    char *aff = aff; /* for compiler */
 
-    opt = getopt32(argv, "+p:", &p_opt);
+    /* NB: we mimic util-linux's taskset: -p does not take
+     * an argument, i.e., "-pN" is NOT valid, only "-p N"!
+     * Indeed, util-linux-2.13-pre7 uses:
+     * getopt_long(argc, argv, "+pchV", ...), not "...p:..." */
 
-    if (opt & OPT_p) {
-        if (argc == optind+1) { /* -p <aff> <pid> */
-            aff = p_opt;
-            p_opt = argv[optind];
+    opt_complementary = "-1"; /* at least 1 arg */
+    opt_p = getopt32(argv, "+p");
+    argv += optind;
+
+    if (opt_p) {
+        pid_str = *argv++;
+        if (*argv) { /* "-p <aff> <pid> ...rest.is.ignored..." */
+            aff = pid_str;
+            pid_str = *argv; /* NB: *argv != NULL in this case */
         }
-        argv += optind; /* me -p <arg> */
-        pid = xatoul_range(p_opt, 1, ULONG_MAX); /* -p <pid> */
-    } else
-        aff = *++argv; /* <aff> <cmd...> */
-    if (aff) {
-        unsigned i = 0;
-        unsigned long l = xstrtol_range(aff, 0, 1, LONG_MAX);
+        /* else it was just "-p <pid>", and *argv == NULL */
+        pid = xatoul_range(pid_str, 1, ((unsigned)(pid_t)ULONG_MAX) >> 1);
+    } else {
+        aff = *argv++; /* <aff> <cmd...> */
+        if (!*argv)
+            bb_show_usage();
+    }
 
-        CPU_ZERO(&new_mask);
-        while (i < CPU_SETSIZE && l >= (1<<i)) {
-            if ((1<<i) & l)
-                CPU_SET(i, &new_mask);
-            ++i;
+    current_new = "current\0new";
+    if (opt_p) {
+ print_aff:
+        if (sched_getaffinity(pid, sizeof(mask), &mask) < 0)
+            bb_perror_msg_and_die("can't %cet pid %d's affinity", 'g', pid);
+        printf("pid %d's %s affinity mask: "TASKSET_PRINTF_MASK"\n",
+                pid, current_new, from_cpuset(&mask));
+        if (!*argv) {
+            /* Either it was just "-p <pid>",
+             * or it was "-p <aff> <pid>" and we came here
+             * for the second time (see goto below) */
+            return EXIT_SUCCESS;
+        }
+        *argv = NULL;
+        current_new += 8; /* "new" */
+    }
+
+    { /* Affinity was specified, translate it into cpu_set_t */
+        unsigned i;
+        /* Do not allow zero mask: */
+        unsigned long long m = xstrtoull_range(aff, 0, 1, ULLONG_MAX);
+        enum { CNT_BIT = CPU_SETSIZE < sizeof(m)*8 ? CPU_SETSIZE : sizeof(m)*8 };
+
+        CPU_ZERO(&mask);
+        for (i = 0; i < CNT_BIT; i++) {
+            unsigned long long bit = (1ULL << i);
+            if (bit & m)
+                CPU_SET(i, &mask);
         }
     }
 
-    if (opt & OPT_p) {
- print_aff:
-        if (sched_getaffinity(pid, sizeof(mask), &mask) < 0)
-            bb_perror_msg_and_die("failed to %cet pid %d's affinity", 'g', pid);
-        printf("pid %d's %s affinity mask: "TASKSET_PRINTF_MASK"\n",
-                pid, state, from_cpuset(mask));
-        if (!*argv) /* no new affinity given or we did print already, done. */
-            return EXIT_SUCCESS;
-    }
+    /* Set pid's or our own (pid==0) affinity */
+    if (sched_setaffinity(pid, sizeof(mask), &mask))
+        bb_perror_msg_and_die("can't %cet pid %d's affinity", 's', pid);
 
-    if (sched_setaffinity(pid, sizeof(new_mask), &new_mask))
-        bb_perror_msg_and_die("failed to %cet pid %d's affinity", 's', pid);
-    if (opt & OPT_p) {
-        state += 8;
-        ++argv;
-        goto print_aff;
-    }
-    ++argv;
-    BB_EXECVP(*argv, argv);
-    bb_perror_msg_and_die("%s", *argv);
+    if (!argv[0]) /* "-p <aff> <pid> [...ignored...]" */
+        goto print_aff; /* print new affinity and exit */
+
+    BB_EXECVP_or_die(argv);
 }
-#undef OPT_p
-#undef TASKSET_PRINTF_MASK
-#undef from_cpuset

branches/2.2.9/mindi-busybox/miscutils/time.c

@@ -1 +1 @@
 /* vi: set sw=4 ts=4: */
-/* `time' utility to display resource usage of processes.
+/* 'time' utility to display resource usage of processes.
    Copyright (C) 1990, 91, 92, 93, 96 Free Software Foundation, Inc.
 
-   Licensed under GPL version 2, see file LICENSE in this tarball for details.
+   Licensed under GPLv2, see file LICENSE in this source tree.
 */
 /* Originally written by David Keppel <pardo@cs.washington.edu>.
@@ -28 +28 @@
 /* The output format for the -p option .*/
 static const char posix_format[] ALIGN1 = "real %e\nuser %U\nsys %S";
-
 
 /* Format string for printing all statistics verbosely.
@@ -57 +56 @@
     "\tExit status: %x";
 
-
 /* Wait for and fill in data on child process PID.
    Return 0 on error, 1 if ok.  */
-
 /* pid_t is short on BSDI, so don't try to promote it.  */
-static int resuse_end(pid_t pid, resource_t * resp)
-{
-    int status;
+static void resuse_end(pid_t pid, resource_t *resp)
+{
     pid_t caught;
 
     /* Ignore signals, but don't ignore the children.  When wait3
        returns the child process, set the time the command finished. */
-    while ((caught = wait3(&status, 0, &resp->ru)) != pid) {
-        if (caught == -1)
-            return 0;
+    while ((caught = wait3(&resp->waitstatus, 0, &resp->ru)) != pid) {
+        if (caught == -1 && errno != EINTR) {
+            bb_perror_msg("wait");
+            return;
+        }
     }
-    resp->elapsed_ms = (monotonic_us() / 1000) - resp->elapsed_ms;
-    resp->waitstatus = status;
-    return 1;
-}
-
-/* Print ARGV, with each entry in ARGV separated by FILLER.  */
-static void printargv(char *const *argv, const char *filler)
-{
-    fputs(*argv, stdout);
-    while (*++argv) {
-        fputs(filler, stdout);
-        fputs(*argv, stdout);
-    }
+    resp->elapsed_ms = monotonic_ms() - resp->elapsed_ms;
+}
+
+static void printargv(char *const *argv)
+{
+    const char *fmt = " %s" + 1;
+    do {
+        printf(fmt, *argv);
+        fmt = " %s";
+    } while (*++argv);
 }
 
@@ -95 +90 @@
    Note: Some machines express getrusage statistics in terms of K,
    others in terms of pages.  */
-
-static unsigned long ptok(unsigned long pages)
-{
-    static unsigned long ps;
+static unsigned long ptok(const unsigned pagesize, const unsigned long pages)
+{
     unsigned long tmp;
 
-    /* Initialization.  */
-    if (ps == 0)
-        ps = getpagesize();
-
     /* Conversion.  */
-    if (pages > (LONG_MAX / ps)) {  /* Could overflow.  */
-        tmp = pages / 1024; /* Smaller first, */
-        return tmp * ps;    /* then larger.  */
+    if (pages > (LONG_MAX / pagesize)) { /* Could overflow.  */
+        tmp = pages / 1024;     /* Smaller first, */
+        return tmp * pagesize;  /* then larger.  */
     }
     /* Could underflow.  */
-    tmp = pages * ps;   /* Larger first, */
-    return tmp / 1024;  /* then smaller.  */
+    tmp = pages * pagesize; /* Larger first, */
+    return tmp / 1024;      /* then smaller.  */
 }
 
@@ -163 +152 @@
 #endif
 
-static void summarize(const char *fmt, char **command, resource_t * resp)
+static void summarize(const char *fmt, char **command, resource_t *resp)
 {
     unsigned vv_ms;     /* Elapsed virtual (CPU) milliseconds */
     unsigned cpu_ticks; /* Same, in "CPU ticks" */
-
+    unsigned pagesize = getpagesize();
+
+    /* Impossible: we do not use WUNTRACED flag in wait()...
     if (WIFSTOPPED(resp->waitstatus))
         printf("Command stopped by signal %u\n",
                 WSTOPSIG(resp->waitstatus));
-    else if (WIFSIGNALED(resp->waitstatus))
+    else */
+    if (WIFSIGNALED(resp->waitstatus))
         printf("Command terminated by signal %u\n",
                 WTERMSIG(resp->waitstatus));
@@ -182 +174 @@
 
 #if (1000 / TICKS_PER_SEC) * TICKS_PER_SEC == 1000
-    /* 1000 is exactly divisible by TICKS_PER_SEC */
+    /* 1000 is exactly divisible by TICKS_PER_SEC (typical) */
     cpu_ticks = vv_ms / (1000 / TICKS_PER_SEC);
 #else
@@ -188 +180 @@
 #endif
     if (!cpu_ticks) cpu_ticks = 1; /* we divide by it, must be nonzero */
-
-    /* putchar() != putc(stdout) in glibc! */
 
     while (*fmt) {
@@ -206 +196 @@
          * for everything. With this we do a lot of 1-byte writes */
         default:
-            putc(*fmt, stdout);
+            bb_putchar(*fmt);
             break;
 #endif
@@ -216 +206 @@
         /* and we do not take format str from user */
             default:
-                putc('%', stdout);
+                bb_putchar('%');
                 /*FALLTHROUGH*/
             case '%':
                 if (!*fmt) goto ret;
-                putc(*fmt, stdout);
+                bb_putchar(*fmt);
                 break;
 #endif
             case 'C':   /* The command that got timed.  */
-                printargv(command, " ");
+                printargv(command);
                 break;
             case 'D':   /* Average unshared data size.  */
                 printf("%lu",
-                        ptok((UL) resp->ru.ru_idrss) / cpu_ticks +
-                        ptok((UL) resp->ru.ru_isrss) / cpu_ticks);
+                    (ptok(pagesize, (UL) resp->ru.ru_idrss) +
+                     ptok(pagesize, (UL) resp->ru.ru_isrss)) / cpu_ticks);
                 break;
             case 'E': { /* Elapsed real (wall clock) time.  */
@@ -253 +243 @@
             case 'K':   /* Average mem usage == data+stack+text.  */
                 printf("%lu",
-                        ptok((UL) resp->ru.ru_idrss) / cpu_ticks +
-                        ptok((UL) resp->ru.ru_isrss) / cpu_ticks +
-                        ptok((UL) resp->ru.ru_ixrss) / cpu_ticks);
+                    (ptok(pagesize, (UL) resp->ru.ru_idrss) +
+                     ptok(pagesize, (UL) resp->ru.ru_isrss) +
+                     ptok(pagesize, (UL) resp->ru.ru_ixrss)) / cpu_ticks);
                 break;
             case 'M':   /* Maximum resident set size.  */
-                printf("%lu", ptok((UL) resp->ru.ru_maxrss));
+                printf("%lu", ptok(pagesize, (UL) resp->ru.ru_maxrss));
                 break;
             case 'O':   /* Outputs.  */
@@ -311 +301 @@
                 break;
             case 'X':   /* Average shared text size.  */
-                printf("%lu", ptok((UL) resp->ru.ru_ixrss) / cpu_ticks);
+                printf("%lu", ptok(pagesize, (UL) resp->ru.ru_ixrss) / cpu_ticks);
                 break;
             case 'Z':   /* Page size.  */
-                printf("%u", getpagesize());
+                printf("%u", pagesize);
                 break;
             case 'c':   /* Involuntary context switches.  */
@@ -328 +318 @@
                 break;
             case 'p':   /* Average stack segment.  */
-                printf("%lu", ptok((UL) resp->ru.ru_isrss) / cpu_ticks);
+                printf("%lu", ptok(pagesize, (UL) resp->ru.ru_isrss) / cpu_ticks);
                 break;
             case 'r':   /* Incoming socket messages received.  */
@@ -337 +327 @@
                 break;
             case 't':   /* Average resident set size.  */
-                printf("%lu", ptok((UL) resp->ru.ru_idrss) / cpu_ticks);
+                printf("%lu", ptok(pagesize, (UL) resp->ru.ru_idrss) / cpu_ticks);
                 break;
             case 'w':   /* Voluntary context switches.  */
@@ -352 +342 @@
             switch (*++fmt) {
             default:
-                putc('\\', stdout);
+                bb_putchar('\\');
                 /*FALLTHROUGH*/
             case '\\':
                 if (!*fmt) goto ret;
-                putc(*fmt, stdout);
+                bb_putchar(*fmt);
                 break;
             case 't':
-                putc('\t', stdout);
+                bb_putchar('\t');
                 break;
             case 'n':
-                putc('\n', stdout);
+                bb_putchar('\n');
                 break;
             }
@@ -371 +361 @@
     }
  /* ret: */
-    putc('\n', stdout);
+    bb_putchar('\n');
 }
 
 /* Run command CMD and return statistics on it.
    Put the statistics in *RESP.  */
-static void run_command(char *const *cmd, resource_t * resp)
-{
-    pid_t pid;          /* Pid of child.  */
-    __sighandler_t interrupt_signal, quit_signal;
-
-    resp->elapsed_ms = monotonic_us() / 1000;
-    pid = vfork();      /* Run CMD as child process.  */
-    if (pid < 0)
-        bb_error_msg_and_die("cannot fork");
-    else if (pid == 0) {    /* If child.  */
-        /* Don't cast execvp arguments; that causes errors on some systems,
-           versus merely warnings if the cast is left off.  */
-        BB_EXECVP(cmd[0], cmd);
-        bb_error_msg("cannot run %s", cmd[0]);
-        _exit(errno == ENOENT ? 127 : 126);
+static void run_command(char *const *cmd, resource_t *resp)
+{
+    pid_t pid;
+    void (*interrupt_signal)(int);
+    void (*quit_signal)(int);
+
+    resp->elapsed_ms = monotonic_ms();
+    pid = xvfork();
+    if (pid == 0) {
+        /* Child */
+        BB_EXECVP_or_die((char**)cmd);
     }
 
     /* Have signals kill the child but not self (if possible).  */
+//TODO: just block all sigs? and reenable them in the very end in main?
     interrupt_signal = signal(SIGINT, SIG_IGN);
     quit_signal = signal(SIGQUIT, SIG_IGN);
 
-    if (resuse_end(pid, resp) == 0)
-        bb_error_msg("error waiting for child process");
+    resuse_end(pid, resp);
 
     /* Re-enable signals.  */
@@ -405 +391 @@
 }
 
-int time_main(int argc, char **argv);
-int time_main(int argc, char **argv)
+int time_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int time_main(int argc UNUSED_PARAM, char **argv)
 {
     resource_t res;
     const char *output_format = default_format;
-    char c;
-
-    goto next;
-    /* Parse any options  -- don't use getopt() here so we don't
-     * consume the args of our client application... */
-    while (argc > 0 && argv[0][0] == '-') {
-        while ((c = *++*argv)) {
-            switch (c) {
-            case 'v':
-                output_format = long_format;
-                break;
-            case 'p':
-                output_format = posix_format;
-                break;
-            default:
-                bb_show_usage();
-            }
-        }
- next:
-        argv++;
-        argc--;
-        if (!argc)
-            bb_show_usage();
-    }
+    int opt;
+
+    opt_complementary = "-1"; /* at least one arg */
+    /* "+": stop on first non-option */
+    opt = getopt32(argv, "+vp");
+    argv += optind;
+    if (opt & 1)
+        output_format = long_format;
+    if (opt & 2)
+        output_format = posix_format;
 
     run_command(argv, &res);
 
     /* Cheat. printf's are shorter :) */
-    stdout = stderr;
-    dup2(2, 1); /* just in case libc does something silly :( */
+    xdup2(STDERR_FILENO, STDOUT_FILENO);
     summarize(output_format, argv, &res);
 
@@ -448 +419 @@
     if (WIFEXITED(res.waitstatus))
         return WEXITSTATUS(res.waitstatus);
-    fflush_stdout_and_exit(0);
-}
+    fflush_stdout_and_exit(EXIT_SUCCESS);
+}

branches/2.2.9/mindi-busybox/miscutils/ttysize.c

@@ -8 +8 @@
  * Copyright (C) 2007 by Denys Vlasenko <vda.linux@googlemail.com>
  *
- * Licensed under the GPL v2, see the file LICENSE in this tarball.
+ * Licensed under GPLv2, see file LICENSE in this source tree.
  */
 #include "libbb.h"
 
-int ttysize_main(int argc, char **argv);
-int ttysize_main(int argc, char **argv)
+int ttysize_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int ttysize_main(int argc UNUSED_PARAM, char **argv)
 {
-    unsigned w,h;
+    unsigned w, h;
     struct winsize wsz;
 
@@ -25 +25 @@
     }
 
-    if (argc == 1) {
+    if (!argv[1]) {
         printf("%u %u", w, h);
     } else {
@@ -40 +40 @@
         }
     }
-    putchar('\n');
+    bb_putchar('\n');
     return 0;
 }

branches/2.2.9/mindi-busybox/miscutils/watchdog.c

@@ -4 +4 @@
  *
  * Copyright (C) 2003  Paul Mundt <lethal@linux-sh.org>
- * Copyright (C) 2006  Bernhard Fischer <busybox@busybox.net>
+ * Copyright (C) 2006  Bernhard Reutner-Fischer <busybox@busybox.net>
+ * Copyright (C) 2008  Darius Augulis <augulis.darius@gmail.com>
  *
- * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
 #include "libbb.h"
+#include "linux/types.h" /* for __u32 */
+#include "linux/watchdog.h"
 
-#define OPT_FOREGROUND 0x01
-#define OPT_TIMER      0x02
+#define OPT_FOREGROUND  (1 << 0)
+#define OPT_STIMER      (1 << 1)
+#define OPT_HTIMER      (1 << 2)
 
-static void watchdog_shutdown(int ATTRIBUTE_UNUSED sig) ATTRIBUTE_NORETURN;
-static void watchdog_shutdown(int ATTRIBUTE_UNUSED sig)
+static void watchdog_shutdown(int sig UNUSED_PARAM)
 {
-    write(3, "V", 1);   /* Magic, see watchdog-api.txt in kernel */
+    static const char V = 'V';
+
+    write(3, &V, 1);  /* Magic, see watchdog-api.txt in kernel */
     if (ENABLE_FEATURE_CLEAN_UP)
         close(3);
-    exit(0);
+    _exit(EXIT_SUCCESS);
 }
 
-int watchdog_main(int argc, char **argv);
+int watchdog_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int watchdog_main(int argc, char **argv)
 {
+    static const struct suffix_mult suffixes[] = {
+        { "ms", 1 },
+        { "", 1000 },
+        { "", 0 }
+    };
+
     unsigned opts;
-    unsigned timer_duration = 30; /* Userspace timer duration, in seconds */
-    char *t_arg;
+    unsigned stimer_duration; /* how often to restart */
+    unsigned htimer_duration = 60000; /* reboots after N ms if not restarted */
+    char *st_arg;
+    char *ht_arg;
 
-    opt_complementary = "=1"; /* must have 1 argument */
-    opts = getopt32(argv, "Ft:", &t_arg);
+    opt_complementary = "=1"; /* must have exactly 1 argument */
+    opts = getopt32(argv, "Ft:T:", &st_arg, &ht_arg);
 
-    if (opts & OPT_TIMER)
-        timer_duration = xatou(t_arg);
+    /* We need to daemonize *before* opening the watchdog as many drivers
+     * will only allow one process at a time to do so.  Since daemonizing
+     * is not perfect (child may run before parent finishes exiting), we
+     * can't rely on parent exiting before us (let alone *cleanly* releasing
+     * the watchdog fd -- something else that may not even be allowed).
+     */
+    if (!(opts & OPT_FOREGROUND))
+        bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
 
-    if (!(opts & OPT_FOREGROUND)) {
-        bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv);
-    }
+    if (opts & OPT_HTIMER)
+        htimer_duration = xatou_sfx(ht_arg, suffixes);
+    stimer_duration = htimer_duration / 2;
+    if (opts & OPT_STIMER)
+        stimer_duration = xatou_sfx(st_arg, suffixes);
 
-    signal(SIGHUP, watchdog_shutdown);
-    signal(SIGINT, watchdog_shutdown);
+    bb_signals(BB_FATAL_SIGS, watchdog_shutdown);
 
     /* Use known fd # - avoid needing global 'int fd' */
     xmove_fd(xopen(argv[argc - 1], O_WRONLY), 3);
 
+    /* WDIOC_SETTIMEOUT takes seconds, not milliseconds */
+    htimer_duration = htimer_duration / 1000;
+#ifndef WDIOC_SETTIMEOUT
+# error WDIOC_SETTIMEOUT is not defined, cannot compile watchdog applet
+#else
+# if defined WDIOC_SETOPTIONS && defined WDIOS_ENABLECARD
+    {
+        static const int enable = WDIOS_ENABLECARD;
+        ioctl_or_warn(3, WDIOC_SETOPTIONS, (void*) &enable);
+    }
+# endif
+    ioctl_or_warn(3, WDIOC_SETTIMEOUT, &htimer_duration);
+#endif
+
+#if 0
+    ioctl_or_warn(3, WDIOC_GETTIMEOUT, &htimer_duration);
+    printf("watchdog: SW timer is %dms, HW timer is %ds\n",
+        stimer_duration, htimer_duration * 1000);
+#endif
+
     while (1) {
         /*
-         * Make sure we clear the counter before sleeping, as the counter value
-         * is undefined at this point -- PFM
+         * Make sure we clear the counter before sleeping,
+         * as the counter value is undefined at this point -- PFM
          */
-        write(3, "", 1);
-        sleep(timer_duration);
+        write(3, "", 1); /* write zero byte */
+        usleep(stimer_duration * 1000L);
     }
-
-    watchdog_shutdown(0);
-    /* return EXIT_SUCCESS; */
+    return EXIT_SUCCESS; /* - not reached, but gcc 4.2.1 is too dumb! */
 }