Ignore:
Timestamp:
Nov 6, 2007, 11:01:53 AM (13 years ago)
Author:
Bruno Cornec
Message:
  • Better output for mindi-busybox revision
  • Remove dummy file created on NFS - report from Arnaud Tiger <arnaud.tiger_at_hp.com>
  • strace useful for debug
  • fix new versions for pb (2.0.0 for mindi and 1.7.2 for mindi-busybox)
  • fix build process for mindi-busybox + options used in that version (dd for label-partitions-as-necessary)
  • fix typo in label-partitions-as-necessary which doesn't seem to work
  • Update to busybox 1.7.2
  • perl is now required at restore time to support uuid swap partitions (and will be used for many other thigs

in the future for sure)

  • next mindi version will be 2.0.0 due to all the changes made in it (udev may break working distros)
  • small optimization in mindi on keyboard handling (one single find instead of multiple)
  • better interaction for USB device when launching mindi manually
  • attempt to automatically guess block disk size for ramdisk
  • fix typos in bkphw
  • Fix the remaining problem with UUID support for swap partitions
  • Updates mondoarchive man page for USB support
  • Adds preliminary Hardware support to mindi (Proliant SSSTK)
  • Tries to add udev support also for rhel4
  • Fix UUID support which was still broken.
  • Be conservative in test for the start-nfs script
  • Update config file for mindi-busybox for 1.7.2 migration
  • Try to run around a busybox bug (1.2.2 pb on inexistant links)
  • Add build content for mindi-busybox in pb
  • Remove distributions content for mindi-busybox
  • Fix a warning on inexistant raidtab
  • Solve problem on tmpfs in restore init (Problem of inexistant symlink and busybox)
  • Create MONDO_CACHE and use it everywhere + creation at start
  • Really never try to eject a USB device
  • Fix a issue with &> usage (replaced with 1> and 2>)
  • Adds magic file to depllist in order to have file working + ldd which helps for debugging issues
  • tty modes correct to avoid sh error messages
  • Use ext3 normally and not ext2 instead
  • USB device should be corrected after reading (take 1st part)
  • Adds a mount_USB_here function derived from mount_CDROM_here
  • usb detection place before /dev detection in device name at restore time
  • Fix when restoring from USB: media is asked in interactive mode
  • Adds USB support for mondorestore
  • mount_cdrom => mount_media
  • elilo.efi is now searched throughout /boot/efi and not in a fixed place as there is no standard
  • untar-and-softlink => untar (+ interface change)
  • suppress useless softlinks creation/removal in boot process
  • avoids udevd messages on groups
  • Increase # of disks to 99 as in mindi at restore time (should be a conf file parameter)
  • skip existing big file creation
  • seems to work correctly for USB mindi boot
  • Adds group and tty link to udev conf
  • Always load usb-torage (even 2.6) to initiate USB bus discovery
  • Better printing of messages
  • Attempt to fix a bug in supporting OpenSusE 10.3 kernel for initramfs (mindi may now use multiple regex for kernel initrd detection)
  • Links were not correctly done as non relative for modules in mindi
  • exclusion of modules denied now works
  • Also create modules in their ordinary place, so that classical modprobe works + copy modules.dep
  • Fix bugs for DENY_MODS handling
  • Add device /dev/console for udev
  • ide-generic should now really be excluded
  • Fix a bug in major number for tty
  • If udev then adds modprobe/insmod to rootfs
  • tty0 is also cretaed with udev
  • ide-generic put rather in DENY_MODS
  • udevd remove from deplist s handled in mindi directly
  • better default for mindi when using --usb
  • Handles dynamically linked busybox (in case we want to use it soon ;-)
  • Adds fixed devices to create for udev
  • ide-generic should not be part of the initrd when using libata v2
  • support a dynamically linked udev (case on Ubuntu 7.10 and Mandriva 2008.0 so should be quite generic) This will give incitation to move to dyn. linked binaries in the initrd which will help for other tasks (ia6 4)
  • Improvement in udev support (do not use cl options not available in busybox)
  • Udev in mindi
    • auto creation of the right links at boot time with udev-links.conf(from Mandriva 2008.0)
    • rework startup of udev as current makes kernel crash (from Mandriva 2008.0)
    • add support for 64 bits udev
  • Try to render MyInsmod? silent at boot time
  • Adds udev support (mandatory for newest distributions to avoid remapping of devices in a different way as on the original system)
  • We also need vaft format support for USB boot
  • Adds libusual support (Ubuntu 7.10 needs it for USB)
  • Improve Ubuntu/Debian? keyboard detection and support
  • pbinit adapted to new pb (0.8.10). Filtering of docs done in it
  • Suppress some mondo warnings and errors on USB again
  • Tries to fix lack of files in deb mindi package
  • Verify should now work for USB devices
  • More log/mesages improvement for USB support
  • - Supress g_erase_tmpdir_and_scratchdir
  • Improve some log messages for USB support
  • Try to improve install in mindi to avoid issues with isolinux.cfg not installed vene if in the pkg :-(
  • Improve mindi-busybox build
  • In conformity with pb 0.8.9
  • Add support for Ubuntu 7.10 in build process
  • Add USB Key button to Menu UI (CD streamer removed)
  • Attempt to fix error messages on tmp/scratch files at the end by removing those dir at the latest possible.
  • Fix a bug linked to the size of the -E param which could be used (Arnaud Tiger/René? Ribaud).
  • Integrate ~/.pbrc content into mondorescue.pb (required project-builder >= 0.8.7)
  • Put mondorescue in conformity with new pb filtering rules
  • Add USB support at restore time (no test done yet). New start-usb script PB varibale added where useful
  • Unmounting USB device before removal of temporary scratchdir
  • Stil refining USB copy back to mondo (one command was not executed)
  • No need to have the image subdor in the csratchdir when USB.
  • umount the USB partition before attempting to use it
  • Remove useless copy from mindi to mondo at end of USB handling

(risky merge, we are raising the limits of 2 diverging branches. The status of stable is not completely sure as such. Will need lots of tests, but it's not yet done :-()
(merge -r1692:1769 $SVN_M/branches/2.2.5)

Location:
branches/stable/mindi-busybox/miscutils
Files:
2 deleted
20 edited
6 copied

Legend:

Unmodified
Added
Removed
  • branches/stable/mindi-busybox/miscutils/Config.in

    r821 r1770  
    66menu "Miscellaneous Utilities"
    77
    8 config CONFIG_ADJTIMEX
     8config ADJTIMEX
    99    bool "adjtimex"
    1010    default n
     
    1313      the Linux clock adjustment algorithm.
    1414
    15 config CONFIG_BBCONFIG
     15config BBCONFIG
    1616    bool "bbconfig"
    1717    default n
     
    2020      busybox was built.
    2121
    22 config CONFIG_CROND
     22config CHRT
     23    bool "chrt"
     24    default n
     25    help
     26      manipulate real-time attributes of a process.
     27      This requires sched_{g,s}etparam support in your libc.
     28
     29config CROND
    2330    bool "crond"
    2431    default n
    25     select CONFIG_FEATURE_SUID
     32    select FEATURE_SUID
     33    select FEATURE_SYSLOG
    2634    help
    2735      Crond is a background daemon that parses individual crontab
     
    3543      work properly.
    3644
    37 config CONFIG_DEBUG_CROND_OPTION
     45config DEBUG_CROND_OPTION
    3846    bool "Support debug option -d"
    39     depends on CONFIG_CROND
     47    depends on CROND
    4048    default n
    4149    help
    4250      Support option -d to enter debug mode.
    4351
    44 config CONFIG_FEATURE_CROND_CALL_SENDMAIL
     52config FEATURE_CROND_CALL_SENDMAIL
    4553    bool "Using /usr/sbin/sendmail?"
    4654    default n
    47     depends on CONFIG_CROND
     55    depends on CROND
    4856    help
    4957      Support calling /usr/sbin/sendmail for send cmd outputs.
    5058
    51 config CONFIG_CRONTAB
     59config CRONTAB
    5260    bool "crontab"
    5361    default n
    54     select CONFIG_FEATURE_SUID
     62    select FEATURE_SUID
    5563    help
    5664      Crontab manipulates the crontab for a particular user.  Only
    5765      the superuser may specify a different user and/or crontab directory.
    5866
    59 config CONFIG_DC
     67config DC
    6068    bool "dc"
    6169    default n
     
    6472      precision arithmetic.
    6573
    66 config CONFIG_DEVFSD
     74config DEVFSD
    6775    bool "devfsd (obsolete)"
    6876    default n
    69     help
    70       This is deprecated, and will be going away in a future release.
     77    select FEATURE_SYSLOG
     78    help
     79      This is deprecated, and will be removed at the end of 2008.
    7180
    7281      Provides compatibility with old device names on a devfs systems.
     
    7988       But only if they are written UPPERCASE!!!!!!!!
    8089
    81 config CONFIG_DEVFSD_MODLOAD
     90config DEVFSD_MODLOAD
    8291    bool "Adds support for MODLOAD keyword in devsfd.conf"
    8392    default n
    84     depends on CONFIG_DEVFSD
     93    depends on DEVFSD
    8594    help
    8695      This actually doesn't work with busybox modutils but needs
    8796      the external modutils.
    8897
    89 config CONFIG_DEVFSD_FG_NP
     98config DEVFSD_FG_NP
    9099    bool "Enables the -fg and -np options"
    91100    default n
    92     depends on CONFIG_DEVFSD
     101    depends on DEVFSD
    93102    help
    94103        -fg Run the daemon in the foreground.
    95104        -np Exit  after  parsing  the configuration file. Do not poll for events.
    96105
    97 config CONFIG_DEVFSD_VERBOSE
     106config DEVFSD_VERBOSE
    98107    bool "Increases logging (and size)"
    99108    default n
    100     depends on CONFIG_DEVFSD
     109    depends on DEVFSD
    101110    help
    102111      Increases logging to stderr or syslog.
    103112
    104 config CONFIG_FEATURE_DEVFS
     113config FEATURE_DEVFS
    105114    bool "  Use devfs names for all devices (obsolete)"
    106115    default n
    107116    help
     117      This is obsolete and will be going away at the end of 2008..
     118
    108119      This tells busybox to look for names like /dev/loop/0 instead of
    109120      /dev/loop0.  If your /dev directory has normal names instead of
    110121      devfs names, you don't want this.
    111122
    112       This is obsolete and will be going away someday.  Consider it
    113       deprecated.
    114 
    115 config CONFIG_EJECT
     123config EJECT
    116124    bool "eject"
    117125    default n
     
    119127      Used to eject cdroms.  (defaults to /dev/cdrom)
    120128
    121 config CONFIG_LAST
     129config LAST
    122130    bool "last"
    123131    default n
    124     select CONFIG_FEATURE_WTMP
     132    select FEATURE_WTMP
    125133    help
    126134      'last' displays a list of the last users that logged into the system.
    127135
    128 config CONFIG_LESS
     136config LESS
    129137    bool "less"
    130138    default n
     
    133141      a wide array of features, and is an improvement over 'more'.
    134142
    135 config CONFIG_FEATURE_LESS_BRACKETS
     143config FEATURE_LESS_MAXLINES
     144    int "Max number of input lines less will try to eat"
     145    default 9999999
     146    depends on LESS
     147
     148config FEATURE_LESS_BRACKETS
    136149    bool "Enable bracket searching"
    137150    default y
    138     depends on CONFIG_LESS
     151    depends on LESS
    139152    help
    140153      This option adds the capability to search for matching left and right
    141154      brackets, facilitating programming.
    142155
    143 config CONFIG_FEATURE_LESS_FLAGS
     156config FEATURE_LESS_FLAGS
    144157    bool "Enable extra flags"
    145158    default y
    146     depends on CONFIG_LESS
     159    depends on LESS
    147160    help
    148161      The extra flags provided do the following:
     
    151164      The -m flag enables a simpler status line with a percentage.
    152165
    153 config CONFIG_FEATURE_LESS_FLAGCS
     166config FEATURE_LESS_FLAGCS
    154167    bool "Enable flag changes"
    155168    default n
    156     depends on CONFIG_LESS
     169    depends on LESS
    157170    help
    158171      This enables the ability to change command-line flags within
    159172      less itself.
    160173
    161 config CONFIG_FEATURE_LESS_MARKS
     174config FEATURE_LESS_MARKS
    162175    bool "Enable marks"
    163176    default n
    164     depends on CONFIG_LESS
     177    depends on LESS
    165178    help
    166179      Marks enable positions in a file to be stored for easy reference.
    167180
    168 config CONFIG_FEATURE_LESS_REGEXP
     181config FEATURE_LESS_REGEXP
    169182    bool "Enable regular expressions"
    170183    default n
    171     depends on CONFIG_LESS
     184    depends on LESS
    172185    help
    173186      Enable regular expressions, allowing complex file searches.
    174187
    175 config CONFIG_HDPARM
     188config HDPARM
    176189    bool "hdparm"
    177190    default n
     
    179192      Get/Set hard drive parameters.  Primarily intended for ATA
    180193      drives.  Adds about 13k (or around 30k if you enable the
    181       CONFIG_FEATURE_HDPARM_GET_IDENTITY option)....
    182 
    183 config CONFIG_FEATURE_HDPARM_GET_IDENTITY
     194      FEATURE_HDPARM_GET_IDENTITY option)....
     195
     196config FEATURE_HDPARM_GET_IDENTITY
    184197    bool "Support obtaining detailed information directly from drives"
    185198    default y
    186     depends on CONFIG_HDPARM
     199    depends on HDPARM
    187200    help
    188201      Enables the -I and -i options to obtain detailed information
     
    191204      identify data from stdin. Enabling this option will add about 16k...
    192205
    193 config CONFIG_FEATURE_HDPARM_HDIO_SCAN_HWIF
     206config FEATURE_HDPARM_HDIO_SCAN_HWIF
    194207    bool "Register an IDE interface (DANGEROUS)"
    195208    default n
    196     depends on CONFIG_HDPARM
     209    depends on HDPARM
    197210    help
    198211      Enables the 'hdparm -R' option to register an IDE interface.
    199212      This is dangerous stuff, so you should probably say N.
    200213
    201 config CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
     214config FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
    202215    bool "Un-register an IDE interface (DANGEROUS)"
    203216    default n
    204     depends on CONFIG_HDPARM
     217    depends on HDPARM
    205218    help
    206219      Enables the 'hdparm -U' option to un-register an IDE interface.
    207220      This is dangerous stuff, so you should probably say N.
    208221
    209 config CONFIG_FEATURE_HDPARM_HDIO_DRIVE_RESET
     222config FEATURE_HDPARM_HDIO_DRIVE_RESET
    210223    bool "perform device reset (DANGEROUS)"
    211224    default n
    212     depends on CONFIG_HDPARM
     225    depends on HDPARM
    213226    help
    214227      Enables the 'hdparm -w' option to perform a device reset.
    215228      This is dangerous stuff, so you should probably say N.
    216229
    217 config CONFIG_FEATURE_HDPARM_HDIO_TRISTATE_HWIF
     230config FEATURE_HDPARM_HDIO_TRISTATE_HWIF
    218231    bool "tristate device for hotswap (DANGEROUS)"
    219232    default n
    220     depends on CONFIG_HDPARM
     233    depends on HDPARM
    221234    help
    222235      Enables the 'hdparm -x' option to tristate device for hotswap,
     
    224237      stuff, so you should probably say N.
    225238
    226 config CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
     239config FEATURE_HDPARM_HDIO_GETSET_DMA
    227240    bool "get/set using_dma flag (DANGEROUS)"
    228241    default n
    229     depends on CONFIG_HDPARM
     242    depends on HDPARM
    230243    help
    231244      Enables the 'hdparm -d' option to get/set using_dma flag.
    232245      This is dangerous stuff, so you should probably say N.
    233246
    234 config CONFIG_MAKEDEVS
     247config MAKEDEVS
    235248    bool "makedevs"
    236249    default n
     
    245258      devices of a particluar type to be created per command.
    246259      e.g. /dev/hda[0-9]
    247           Device properties are passed as command line arguments.
     260      Device properties are passed as command line arguments.
    248261      .
    249262      'table' reads device properties from a file or stdin, allowing
    250263      a batch of unrelated devices to be made with one command.
    251           User/group names are allowed as an alternative to uid/gid.
     264      User/group names are allowed as an alternative to uid/gid.
    252265
    253266choice
    254267    prompt "Choose makedevs behaviour"
    255     depends CONFIG_MAKEDEVS
    256     default CONFIG_FEATURE_MAKEDEVS_TABLE
    257 
    258 config CONFIG_FEATURE_MAKEDEVS_LEAF
    259         bool "leaf"
    260 
    261 config CONFIG_FEATURE_MAKEDEVS_TABLE
     268    depends on MAKEDEVS
     269    default FEATURE_MAKEDEVS_TABLE
     270
     271config FEATURE_MAKEDEVS_LEAF
     272    bool "leaf"
     273
     274config FEATURE_MAKEDEVS_TABLE
    262275    bool "table"
    263276
    264277endchoice
    265278
    266 config CONFIG_MOUNTPOINT
     279config MOUNTPOINT
    267280    bool "mountpoint"
    268281    default n
     
    270283      mountpoint checks if the directory is a mountpoint.
    271284
    272 config CONFIG_MT
     285config MT
    273286    bool "mt"
    274287    default n
     
    278291      files on the tape.
    279292
    280 config CONFIG_RUNLEVEL
    281         bool "runlevel"
    282     default n
    283     help
    284       find the current and previous system runlevel.
     293config RAIDAUTORUN
     294    bool "raidautorun"
     295    default n
     296    help
     297      raidautorun tells the kernel md driver to
     298      search and start RAID arrays.
     299
     300config READAHEAD
     301    bool "readahead"
     302    default n
     303    depends on LFS
     304    help
     305      Preload the files listed on the command line into RAM cache so that
     306      subsequent reads on these files will not block on disk I/O.
     307
     308      This applet just calls the readahead(2) system call on each file.
     309      It is mainly useful in system startup scripts to preload files
     310      or executables before they are used.  When used at the right time
     311      (in particular when a CPU boundprocess is running) it can
     312      significantly speed up system startup.
     313
     314      As readahead(2) blocks until each file has been read, it is best to
     315      run this applet as a background job.
     316
     317config RUNLEVEL
     318    bool "runlevel"
     319    default n
     320    help
     321      find the current and previous system runlevel.
    285322
    286323      This applet uses utmp but does not rely on busybox supporing
    287324      utmp on purpose. It is used by e.g. emdebian via /etc/init.d/rc.
    288325
    289 config CONFIG_RX
    290         bool "rx"
    291     default n
    292     help
    293       Receive files using the Xmodem protocol.
    294 
    295 config CONFIG_STRINGS
     326config RX
     327    bool "rx"
     328    default n
     329    help
     330      Receive files using the Xmodem protocol.
     331
     332config STRINGS
    296333    bool "strings"
    297334    default n
     
    300337      specified.
    301338
    302 config CONFIG_SETSID
     339config SETSID
    303340    bool "setsid"
    304341    default n
     
    306343      setsid runs a program in a new session
    307344
    308 config CONFIG_TASKSET
     345config TASKSET
    309346    bool "taskset"
    310347    default n
    311348    help
    312       Retrieve or set a processes's CPU affinity
    313 
    314 config CONFIG_TASKSET
    315     bool "taskset"
    316     default n
    317     help
    318       Retrieve or set a processes's CPU affinity (on linux)
    319 
    320 config CONFIG_TIME
     349      Retrieve or set a processes's CPU affinity.
     350      This requires sched_{g,s}etaffinity support in your libc.
     351
     352config FEATURE_TASKSET_FANCY
     353    bool "fancy output"
     354    default y
     355    depends on TASKSET
     356    help
     357      Add code for fancy output. This merely silences a compiler-warning
     358      and adds about 135 Bytes. May be needed for machines with alot
     359      of CPUs.
     360
     361config TIME
    321362    bool "time"
    322363    default n
     
    326367      giving timing statistics about this program run.
    327368
    328 config CONFIG_WATCHDOG
     369config TTYSIZE
     370    bool "ttysize"
     371    default n
     372    help
     373      A replacement for "stty size". Unlike stty, can report only width,
     374      only height, or both, in any order. It also does not complain on error,
     375      but returns default 80x24. Usage in shell scripts: width=`ttysize w`.
     376
     377config WATCHDOG
    329378    bool "watchdog"
    330379    default n
  • branches/stable/mindi-busybox/miscutils/adjtimex.c

    r821 r1770  
    1212 */
    1313
    14 #include "busybox.h"
    15 #include <stdio.h>
    16 #include <sys/types.h>
    17 #include <stdlib.h>
    18 #include <unistd.h>
     14#include "libbb.h"
    1915#include <sys/timex.h>
    2016
    21 static const struct {int bit; const char *name;} statlist[] = {
     17static const struct {
     18    int bit;
     19    const char *name;
     20} statlist[] = {
    2221    { STA_PLL,       "PLL"       },
    2322    { STA_PPSFREQ,   "PPSFREQ"   },
     
    3332    { STA_PPSERROR,  "PPSERROR"  },
    3433    { STA_CLOCKERR,  "CLOCKERR"  },
    35     { 0, NULL } };
     34    { 0, NULL }
     35};
    3636
    37 static const char * const ret_code_descript[] = {
     37static const char *const ret_code_descript[] = {
    3838    "clock synchronized",
    3939    "insert leap second",
     
    4141    "leap second in progress",
    4242    "leap second has occurred",
    43     "clock not synchronized" };
     43    "clock not synchronized"
     44};
    4445
     46int adjtimex_main(int argc, char **argv);
    4547int adjtimex_main(int argc, char **argv)
    4648{
     49    enum {
     50        OPT_quiet = 0x1
     51    };
     52    unsigned opt;
     53    char *opt_o, *opt_f, *opt_p, *opt_t;
    4754    struct timex txc;
    48     int quiet=0;
    49     int c, i, ret, sep;
     55    int i, ret, sep;
    5056    const char *descript;
    5157    txc.modes=0;
    52     for (;;) {
    53         c = getopt( argc, argv, "qo:f:p:t:");
    54         if (c == EOF) break;
    55         switch (c) {
    56             case 'q':
    57                 quiet=1;
    58                 break;
    59             case 'o':
    60                 txc.offset = atoi(optarg);
    61                 txc.modes |= ADJ_OFFSET_SINGLESHOT;
    62                 break;
    63             case 'f':
    64                 txc.freq = atoi(optarg);
    65                 txc.modes |= ADJ_FREQUENCY;
    66                 break;
    67             case 'p':
    68                 txc.constant = atoi(optarg);
    69                 txc.modes |= ADJ_TIMECONST;
    70                 break;
    71             case 't':
    72                 txc.tick = atoi(optarg);
    73                 txc.modes |= ADJ_TICK;
    74                 break;
    75             default:
    76                 bb_show_usage();
    77                 exit(1);
    78         }
     58
     59    opt = getopt32(argv, "qo:f:p:t:",
     60            &opt_o, &opt_f, &opt_p, &opt_t);
     61    //if (opt & 0x1) // -q
     62    if (opt & 0x2) { // -o
     63        txc.offset = xatol(opt_o);
     64        txc.modes |= ADJ_OFFSET_SINGLESHOT;
     65    }
     66    if (opt & 0x4) { // -f
     67        txc.freq = xatol(opt_f);
     68        txc.modes |= ADJ_FREQUENCY;
     69    }
     70    if (opt & 0x8) { // -p
     71        txc.constant = xatol(opt_p);
     72        txc.modes |= ADJ_TIMECONST;
     73    }
     74    if (opt & 0x10) { // -t
     75        txc.tick = xatol(opt_t);
     76        txc.modes |= ADJ_TICK;
    7977    }
    8078    if (argc != optind) { /* no valid non-option parameters */
    8179        bb_show_usage();
    82         exit(1);
    8380    }
    8481
     
    8784    if (ret < 0) perror("adjtimex");
    8885
    89     if (!quiet && ret>=0) {
     86    if (!(opt & OPT_quiet) && ret>=0) {
    9087        printf(
    9188            "    mode:         %d\n"
  • branches/stable/mindi-busybox/miscutils/bbconfig.c

    r821 r1770  
    22/* This file was released into the public domain by Paul Fox.
    33 */
    4 #include "busybox.h"
     4#include "libbb.h"
    55#include "bbconfigopts.h"
    66
     7int bbconfig_main(int argc, char **argv);
    78int bbconfig_main(int argc, char **argv)
    89{
  • branches/stable/mindi-busybox/miscutils/crond.c

    r821 r1770  
    66 *
    77 * Copyright 1994 Matthew Dillon (dillon@apollo.west.oic.com)
     8 * (version 2.3.2)
    89 * Vladimir Oleynik <dzo@simtreas.ru> (C) 2002
    910 *
     
    1112 */
    1213
    13 #define VERSION "2.3.2"
    14 
    15 #include "busybox.h"
    16 #include <stdio.h>
    17 #include <stdlib.h>
    18 #include <stdarg.h>
    19 #include <string.h>
    20 #include <errno.h>
    21 #include <time.h>
    22 #include <dirent.h>
    23 #include <fcntl.h>
    24 #include <unistd.h>
    25 #include <syslog.h>
    26 #include <signal.h>
    27 #include <getopt.h>
    28 #include <sys/ioctl.h>
    29 #include <sys/wait.h>
    30 #include <sys/stat.h>
    31 #include <sys/resource.h>
    32 
    33 #define arysize(ary)    (sizeof(ary)/sizeof((ary)[0]))
     14#include <sys/syslog.h>
     15#include "libbb.h"
    3416
    3517#ifndef CRONTABS
     
    4022#endif
    4123#ifndef SENDMAIL
    42 #define SENDMAIL        "/usr/sbin/sendmail"
     24#define SENDMAIL        "sendmail"
    4325#endif
    4426#ifndef SENDMAIL_ARGS
     
    8163
    8264#if ENABLE_DEBUG_CROND_OPTION
    83 static short DebugOpt;
    84 #endif
    85 
    86 static short LogLevel = 8;
     65static unsigned DebugOpt;
     66#endif
     67
     68static unsigned LogLevel = 8;
    8769static const char *LogFile;
    8870static const char *CDir = CRONTABS;
     
    130112            vsyslog(type, fmt, va);
    131113        } else {
     114#if !ENABLE_DEBUG_CROND_OPTION
    132115            int logfd = open(LogFile, O_WRONLY | O_CREAT | O_APPEND, 0600);
     116#else
     117            int logfd = open3_or_warn(LogFile, O_WRONLY | O_CREAT | O_APPEND, 0600);
     118#endif
    133119            if (logfd >= 0) {
    134120                vdprintf(logfd, fmt, va);
    135121                close(logfd);
    136 #if ENABLE_DEBUG_CROND_OPTION
    137             } else {
    138                 bb_perror_msg("Can't open log file");
    139 #endif
    140122            }
    141123        }
     
    147129}
    148130
     131int crond_main(int ac, char **av);
    149132int crond_main(int ac, char **av)
    150133{
    151     unsigned long opt;
     134    unsigned opt;
    152135    char *lopt, *Lopt, *copt;
    153 
    154 #if ENABLE_DEBUG_CROND_OPTION
    155     char *dopt;
    156 
    157     bb_opt_complementally = "f-b:b-f:S-L:L-S:d-l";
    158 #else
    159     bb_opt_complementally = "f-b:b-f:S-L:L-S";
    160 #endif
    161 
     136    USE_DEBUG_CROND_OPTION(char *dopt;)
     137
     138    opt_complementary = "f-b:b-f:S-L:L-S" USE_DEBUG_CROND_OPTION(":d-l");
    162139    opterr = 0;         /* disable getopt 'errors' message. */
    163     opt = bb_getopt_ulflags(ac, av, "l:L:fbSc:"
    164 #if ENABLE_DEBUG_CROND_OPTION
    165                             "d:"
    166 #endif
    167                             , &lopt, &Lopt, &copt
    168 #if ENABLE_DEBUG_CROND_OPTION
    169                             , &dopt
    170 #endif
    171         );
    172     if (opt & 1) {
    173         LogLevel = atoi(lopt);
    174     }
    175     if (opt & 2) {
    176         if (*Lopt != 0) {
     140    opt = getopt32(av, "l:L:fbSc:" USE_DEBUG_CROND_OPTION("d:"),
     141            &lopt, &Lopt, &copt USE_DEBUG_CROND_OPTION(, &dopt));
     142    if (opt & 1) /* -l */
     143        LogLevel = xatou(lopt);
     144    if (opt & 2) /* -L */
     145        if (*Lopt)
    177146            LogFile = Lopt;
    178         }
    179     }
    180     if (opt & 32) {
    181         if (*copt != 0) {
     147    if (opt & 32) /* -c */
     148        if (*copt)
    182149            CDir = copt;
    183         }
    184     }
    185 #if ENABLE_DEBUG_CROND_OPTION
    186     if (opt & 64) {
    187         DebugOpt = atoi(dopt);
     150#if ENABLE_DEBUG_CROND_OPTION
     151    if (opt & 64) { /* -d */
     152        DebugOpt = xatou(dopt);
    188153        LogLevel = 0;
    189154    }
    190155#endif
    191156
    192     /*
    193      * change directory
    194      */
    195 
    196     bb_xchdir(CDir);
    197     signal(SIGHUP, SIG_IGN);    /* hmm.. but, if kill -HUP original
    198                                  * version - his died. ;(
    199                                  */
    200     /*
    201      * close stdin and stdout, stderr.
     157    /* close stdin and stdout, stderr.
    202158     * close unused descriptors -  don't need.
    203159     * optional detach from controlling terminal
    204160     */
    205 
    206     if (!(opt & 4)) {
    207 #ifdef BB_NOMMU
    208         /* reexec for vfork() do continue parent */
    209         vfork_daemon_rexec(1, 0, ac, av, "-f");
    210 #else
    211         bb_xdaemon(1, 0);
    212 #endif
    213     }
    214 
    215     (void) startlogger();   /* need if syslog mode selected */
     161    if (!(opt & 4))
     162        bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, av);
     163
     164    xchdir(CDir);
     165    signal(SIGHUP, SIG_IGN); /* ? original crond dies on HUP... */
     166
     167    startlogger();  /* need if syslog mode selected */
    216168
    217169    /*
     
    219171     *             of 1 second.
    220172     */
    221 
    222     crondlog("\011%s " VERSION " dillon, started, log level %d\n",
    223              bb_applet_name, LogLevel);
     173    crondlog("\011%s " BB_VER " started, log level %d\n",
     174             applet_name, LogLevel);
    224175
    225176    SynchronizeDir();
     
    232183        short sleep_time = 60;
    233184
     185        write_pidfile("/var/run/crond.pid");
    234186        for (;;) {
    235187            sleep((sleep_time + 1) - (short) (time(NULL) % sleep_time));
     
    280232        }
    281233    }
    282     bb_fflush_stdout_and_exit(EXIT_SUCCESS); /* not reached */
     234    return 0; /* not reached */
    283235}
    284236
     
    294246    if (pas == 0) {
    295247        crondlog("\011failed to get uid for %s", user);
    296         return (-1);
     248        return -1;
    297249    }
    298250    setenv("USER", pas->pw_name, 1);
     
    306258    if (err_msg) {
    307259        crondlog("\011%s for user %s", err_msg, user);
    308         return (-1);
     260        return -1;
    309261    }
    310262    if (chdir(pas->pw_dir) < 0) {
     
    312264        if (chdir(TMPDIR) < 0) {
    313265            crondlog("\011chdir failed: %s: %m", TMPDIR);
    314             return (-1);
    315         }
    316     }
    317     return (pas->pw_uid);
     266            return -1;
     267        }
     268    }
     269    return pas->pw_uid;
    318270}
    319271
     
    321273{
    322274    if (LogFile == 0) {
    323         openlog(bb_applet_name, LOG_CONS | LOG_PID, LOG_CRON);
     275        openlog(applet_name, LOG_CONS | LOG_PID, LOG_CRON);
    324276    }
    325277#if ENABLE_DEBUG_CROND_OPTION
     
    327279        int logfd;
    328280
    329         if ((logfd = open(LogFile, O_WRONLY | O_CREAT | O_APPEND, 0600)) >= 0) {
     281        logfd = open3_or_warn(LogFile, O_WRONLY | O_CREAT | O_APPEND, 0600);
     282        if (logfd >= 0) {
    330283            close(logfd);
    331         } else {
    332             bb_perror_msg("Failed to open log file '%s' reason", LogFile);
    333         }
    334     }
    335 #endif
    336 }
    337 
    338 
    339 static const char *const DowAry[] = {
    340     "sun",
    341     "mon",
    342     "tue",
    343     "wed",
    344     "thu",
    345     "fri",
    346     "sat",
    347 
    348     "Sun",
    349     "Mon",
    350     "Tue",
    351     "Wed",
    352     "Thu",
    353     "Fri",
    354     "Sat",
    355     NULL
    356 };
    357 
    358 static const char *const MonAry[] = {
    359     "jan",
    360     "feb",
    361     "mar",
    362     "apr",
    363     "may",
    364     "jun",
    365     "jul",
    366     "aug",
    367     "sep",
    368     "oct",
    369     "nov",
    370     "dec",
    371 
    372     "Jan",
    373     "Feb",
    374     "Mar",
    375     "Apr",
    376     "May",
    377     "Jun",
    378     "Jul",
    379     "Aug",
    380     "Sep",
    381     "Oct",
    382     "Nov",
    383     "Dec",
    384     NULL
    385 };
     284        }
     285    }
     286#endif
     287}
     288
     289
     290static const char DowAry[] ALIGN1 =
     291    "sun""mon""tue""wed""thu""fri""sat"
     292    /* "Sun""Mon""Tue""Wed""Thu""Fri""Sat" */
     293;
     294
     295static const char MonAry[] ALIGN1 =
     296    "jan""feb""mar""apr""may""jun""jul""aug""sep""oct""nov""dec"
     297    /* "Jan""Feb""Mar""Apr""May""Jun""Jul""Aug""Sep""Oct""Nov""Dec" */
     298;
    386299
    387300static char *ParseField(char *user, char *ary, int modvalue, int off,
    388                         const char *const *names, char *ptr)
     301                const char *names, char *ptr)
     302/* 'names' is a pointer to a set of 3-char abbreviations */
    389303{
    390304    char *base = ptr;
     
    393307
    394308    if (base == NULL) {
    395         return (NULL);
     309        return NULL;
    396310    }
    397311
     
    416330            int i;
    417331
    418             for (i = 0; names[i]; ++i) {
    419                 if (strncmp(ptr, names[i], strlen(names[i])) == 0) {
     332            for (i = 0; names[i]; i += 3) {
     333                /* was using strncmp before... */
     334                if (strncasecmp(ptr, &names[i], 3) == 0) {
     335                    ptr += 3;
     336                    if (n1 < 0) {
     337                        n1 = i / 3;
     338                    } else {
     339                        n2 = i / 3;
     340                    }
     341                    skip = 1;
    420342                    break;
    421343                }
    422             }
    423             if (names[i]) {
    424                 ptr += strlen(names[i]);
    425                 if (n1 < 0) {
    426                     n1 = i;
    427                 } else {
    428                     n2 = i;
    429                 }
    430                 skip = 1;
    431344            }
    432345        }
     
    436349        if (skip == 0) {
    437350            crondlog("\111failed user %s parsing %s\n", user, base);
    438             return (NULL);
     351            return NULL;
    439352        }
    440353        if (*ptr == '-' && n2 < 0) {
     
    476389            if (failsafe == 0) {
    477390                crondlog("\111failed user %s parsing %s\n", user, base);
    478                 return (NULL);
     391                return NULL;
    479392            }
    480393        }
     
    489402    if (*ptr != ' ' && *ptr != '\t' && *ptr != '\n') {
    490403        crondlog("\111failed user %s parsing %s\n", user, base);
    491         return (NULL);
     404        return NULL;
    492405    }
    493406
     
    506419#endif
    507420
    508     return (ptr);
     421    return ptr;
    509422}
    510423
     
    515428    int daysUsed = 0;
    516429
    517     for (i = 0; i < (int)(arysize(line->cl_Dow)); ++i) {
     430    for (i = 0; i < (int)(ARRAY_SIZE(line->cl_Dow)); ++i) {
    518431        if (line->cl_Dow[i] == 0) {
    519432            weekUsed = 1;
     
    521434        }
    522435    }
    523     for (i = 0; i < (int)(arysize(line->cl_Days)); ++i) {
     436    for (i = 0; i < (int)(ARRAY_SIZE(line->cl_Days)); ++i) {
    524437        if (line->cl_Days[i] == 0) {
    525438            daysUsed = 1;
     
    558471
    559472            if (fstat(fileno(fi), &sbuf) == 0 && sbuf.st_uid == DaemonUid) {
    560                 CronFile *file = calloc(1, sizeof(CronFile));
     473                CronFile *file = xzalloc(sizeof(CronFile));
    561474                CronLine **pline;
    562475
     
    602515                    FixDayDow(&line);
    603516
    604                     *pline = calloc(1, sizeof(CronLine));
     517                    *pline = xzalloc(sizeof(CronLine));
    605518                    **pline = line;
    606519
     
    670583    remove(CRONUPDATE);
    671584    if (chdir(CDir) < 0) {
    672         crondlog("\311unable to find %s\n", CDir);
     585        crondlog("\311cannot find %s\n", CDir);
    673586    }
    674587    {
     
    689602            closedir(dir);
    690603        } else {
    691             crondlog("\311Unable to open current dir!\n");
     604            crondlog("\311cannot open current dir!\n");
    692605        }
    693606    }
     
    793706        }
    794707    }
    795     return (nJobs);
     708    return nJobs;
    796709}
    797710
     
    859772        nStillRunning += file->cf_Running;
    860773    }
    861     return (nStillRunning);
     774    return nStillRunning;
    862775}
    863776
     
    892805        }
    893806        execl(prog, prog, cmd, arg, NULL);
    894         crondlog("\024unable to exec, user %s cmd %s %s %s\n", user, prog, cmd, arg);
     807        crondlog("\024cannot exec, user %s cmd %s %s %s\n", user, prog, cmd, arg);
    895808        if (mailf) {
    896809            fdprintf(1, "Exec failed: %s -c %s\n", prog, arg);
     
    899812    } else if (pid < 0) {
    900813        /* FORK FAILED */
    901         crondlog("\024couldn't fork, user %s\n", user);
     814        crondlog("\024cannot fork, user %s\n", user);
    902815        line->cl_Pid = 0;
    903816        if (mailf) {
     
    940853        fdprintf(mailFd, "To: %s\nSubject: cron: %s\n\n", user,
    941854            line->cl_Shell);
    942         line->cl_MailPos = lseek(mailFd, 0, 1);
     855        line->cl_MailPos = lseek(mailFd, 0, SEEK_CUR);
    943856    } else {
    944         crondlog("\024unable to create mail file user %s file %s, output to /dev/null\n", user, mailFile);
     857        crondlog("\024cannot create mail file user %s file %s, output to /dev/null\n", user, mailFile);
    945858    }
    946859
     
    989902    }
    990903
    991     if (fstat(mailFd, &sbuf) < 0 || sbuf.st_uid != DaemonUid || sbuf.st_nlink != 0 ||
    992         sbuf.st_size == line->cl_MailPos || !S_ISREG(sbuf.st_mode)) {
     904    if (fstat(mailFd, &sbuf) < 0 || sbuf.st_uid != DaemonUid
     905     || sbuf.st_nlink != 0 || sbuf.st_size == line->cl_MailPos
     906     || !S_ISREG(sbuf.st_mode)
     907    ) {
    993908        close(mailFd);
    994909        return;
     
    1019934
    1020935        execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", line->cl_Shell, NULL);
    1021         crondlog("\024unable to exec, user %s cmd %s -c %s\n", user,
     936        crondlog("\024cannot exec, user %s cmd %s -c %s\n", user,
    1022937                 DEFAULT_SHELL, line->cl_Shell);
    1023938        exit(0);
    1024939    } else if (pid < 0) {
    1025940        /* FORK FAILED */
    1026         crondlog("\024couldn't fork, user %s\n", user);
     941        crondlog("\024cannot, user %s\n", user);
    1027942        pid = 0;
    1028943    }
  • branches/stable/mindi-busybox/miscutils/crontab.c

    r821 r1770  
    1111 */
    1212
    13 #include "busybox.h"
    14 #include <stdio.h>
    15 #include <stdlib.h>
    16 #include <stdarg.h>
    17 #include <string.h>
    18 #include <errno.h>
    19 #include <time.h>
    20 #include <dirent.h>
    21 #include <fcntl.h>
    22 #include <unistd.h>
    23 #include <syslog.h>
    24 #include <signal.h>
    25 #include <getopt.h>
    26 #include <sys/ioctl.h>
    27 #include <sys/wait.h>
    28 #include <sys/stat.h>
    29 #include <sys/resource.h>
     13#include "libbb.h"
    3014
    3115#ifndef CRONTABS
     
    3923#endif
    4024#ifndef PATH_VI
    41 #define PATH_VI         "/bin/vi"   /* location of vi       */
     25#define PATH_VI         "/bin/vi"   /* location of vi */
    4226#endif
    4327
    44 static const char  *CDir = CRONTABS;
     28static const char *CDir = CRONTABS;
    4529
    4630static void EditFile(const char *user, const char *file);
    4731static int GetReplaceStream(const char *user, const char *file);
    48 static int  ChangeUser(const char *user, short dochdir);
    49 
    50 int
    51 crontab_main(int ac, char **av)
     32static int ChangeUser(const char *user, short dochdir);
     33
     34int crontab_main(int ac, char **av);
     35int crontab_main(int ac, char **av)
    5236{
    53     enum { NONE, EDIT, LIST, REPLACE, DELETE } option = NONE;
    54     const struct passwd *pas;
    55     const char *repFile = NULL;
    56     int repFd = 0;
    57     int i;
    58     char caller[256];           /* user that ran program */
    59     int   UserId;
    60 
    61     UserId = getuid();
    62     if ((pas = getpwuid(UserId)) == NULL)
    63     bb_perror_msg_and_die("getpwuid");
    64 
    65     safe_strncpy(caller, pas->pw_name, sizeof(caller));
    66 
    67     i = 1;
    68     if (ac > 1) {
    69     if (av[1][0] == '-' && av[1][1] == 0) {
    70         option = REPLACE;
    71         ++i;
    72     } else if (av[1][0] != '-') {
    73         option = REPLACE;
    74         ++i;
    75         repFile = av[1];
    76     }
    77     }
    78 
    79     for (; i < ac; ++i) {
    80     char *ptr = av[i];
    81 
    82     if (*ptr != '-')
    83         break;
    84     ptr += 2;
    85 
    86     switch(ptr[-1]) {
    87     case 'l':
    88         if (ptr[-1] == 'l')
    89         option = LIST;
    90         /* fall through */
    91     case 'e':
    92         if (ptr[-1] == 'e')
    93         option = EDIT;
    94         /* fall through */
    95     case 'd':
    96         if (ptr[-1] == 'd')
    97         option = DELETE;
    98         /* fall through */
    99     case 'u':
    100         if (i + 1 < ac && av[i+1][0] != '-') {
    101         ++i;
    102         if (getuid() == geteuid()) {
    103             pas = getpwnam(av[i]);
    104             if (pas) {
    105             UserId = pas->pw_uid;
    106             } else {
    107             bb_error_msg_and_die("user %s unknown", av[i]);
    108             }
    109         } else {
    110             bb_error_msg_and_die("only the superuser may specify a user");
    111         }
    112         }
    113         break;
    114     case 'c':
    115         if (getuid() == geteuid()) {
    116         CDir = (*ptr) ? ptr : av[++i];
    117         } else {
    118         bb_error_msg_and_die("-c option: superuser only");
    119         }
    120         break;
     37    enum { NONE, EDIT, LIST, REPLACE, DELETE } option = NONE;
     38    const struct passwd *pas;
     39    const char *repFile = NULL;
     40    int repFd = 0;
     41    int i;
     42    char caller[256];           /* user that ran program */
     43    char buf[1024];
     44    int UserId;
     45
     46    UserId = getuid();
     47    pas = getpwuid(UserId);
     48    if (pas == NULL)
     49        bb_perror_msg_and_die("getpwuid");
     50
     51    safe_strncpy(caller, pas->pw_name, sizeof(caller));
     52
     53    i = 1;
     54    if (ac > 1) {
     55        if (LONE_DASH(av[1])) {
     56            option = REPLACE;
     57            ++i;
     58        } else if (av[1][0] != '-') {
     59            option = REPLACE;
     60            ++i;
     61            repFile = av[1];
     62        }
     63    }
     64
     65    for (; i < ac; ++i) {
     66        char *ptr = av[i];
     67
     68        if (*ptr != '-')
     69            break;
     70        ptr += 2;
     71
     72        switch (ptr[-1]) {
     73        case 'l':
     74            if (ptr[-1] == 'l')
     75                option = LIST;
     76            /* fall through */
     77        case 'e':
     78            if (ptr[-1] == 'e')
     79                option = EDIT;
     80            /* fall through */
     81        case 'd':
     82            if (ptr[-1] == 'd')
     83                option = DELETE;
     84            /* fall through */
     85        case 'u':
     86            if (i + 1 < ac && av[i+1][0] != '-') {
     87                ++i;
     88                if (getuid() == geteuid()) {
     89                    pas = getpwnam(av[i]);
     90                    if (pas) {
     91                        UserId = pas->pw_uid;
     92                    } else {
     93                        bb_error_msg_and_die("user %s unknown", av[i]);
     94                    }
     95                } else {
     96                    bb_error_msg_and_die("only the superuser may specify a user");
     97                }
     98            }
     99            break;
     100        case 'c':
     101            if (getuid() == geteuid()) {
     102                CDir = (*ptr) ? ptr : av[++i];
     103            } else {
     104                bb_error_msg_and_die("-c option: superuser only");
     105            }
     106            break;
     107        default:
     108            i = ac;
     109            break;
     110        }
     111    }
     112    if (i != ac || option == NONE)
     113        bb_show_usage();
     114
     115    /*
     116     * Get password entry
     117     */
     118
     119    pas = getpwuid(UserId);
     120    if (pas == NULL)
     121        bb_perror_msg_and_die("getpwuid");
     122
     123    /*
     124     * If there is a replacement file, obtain a secure descriptor to it.
     125     */
     126
     127    if (repFile) {
     128        repFd = GetReplaceStream(caller, repFile);
     129        if (repFd < 0)
     130            bb_error_msg_and_die("cannot read replacement file");
     131    }
     132
     133    /*
     134     * Change directory to our crontab directory
     135     */
     136
     137    xchdir(CDir);
     138
     139    /*
     140     * Handle options as appropriate
     141     */
     142
     143    switch (option) {
     144    case LIST:
     145        {
     146            FILE *fi;
     147
     148            fi = fopen(pas->pw_name, "r");
     149            if (fi) {
     150                while (fgets(buf, sizeof(buf), fi) != NULL)
     151                    fputs(buf, stdout);
     152                fclose(fi);
     153            } else {
     154                bb_error_msg("no crontab for %s", pas->pw_name);
     155            }
     156        }
     157        break;
     158    case EDIT:
     159        {
     160/* FIXME: messy code here! we have file copying helpers for this! */
     161            FILE *fi;
     162            int fd;
     163            int n;
     164            char tmp[128];
     165
     166            snprintf(tmp, sizeof(tmp), TMPDIR "/crontab.%d", getpid());
     167            fd = xopen3(tmp, O_RDWR|O_CREAT|O_TRUNC|O_EXCL, 0600);
     168/* race, use fchown */
     169            chown(tmp, getuid(), getgid());
     170            fi = fopen(pas->pw_name, "r");
     171            if (fi) {
     172                while ((n = fread(buf, 1, sizeof(buf), fi)) > 0)
     173                    full_write(fd, buf, n);
     174            }
     175            EditFile(caller, tmp);
     176            remove(tmp);
     177            lseek(fd, 0L, SEEK_SET);
     178            repFd = fd;
     179        }
     180        option = REPLACE;
     181        /* fall through */
     182    case REPLACE:
     183        {
     184/* same here */
     185            char path[1024];
     186            int fd;
     187            int n;
     188
     189            snprintf(path, sizeof(path), "%s.new", pas->pw_name);
     190            fd = open(path, O_CREAT|O_TRUNC|O_APPEND|O_WRONLY, 0600);
     191            if (fd >= 0) {
     192                while ((n = read(repFd, buf, sizeof(buf))) > 0) {
     193                    full_write(fd, buf, n);
     194                }
     195                close(fd);
     196                rename(path, pas->pw_name);
     197            } else {
     198                bb_error_msg("cannot create %s/%s", CDir, path);
     199            }
     200            close(repFd);
     201        }
     202        break;
     203    case DELETE:
     204        remove(pas->pw_name);
     205        break;
     206    case NONE:
    121207    default:
    122         i = ac;
    123         break;
    124     }
    125     }
    126     if (i != ac || option == NONE)
    127     bb_show_usage();
    128 
    129     /*
    130      * Get password entry
    131      */
    132 
    133     if ((pas = getpwuid(UserId)) == NULL)
    134     bb_perror_msg_and_die("getpwuid");
    135 
    136     /*
    137      * If there is a replacement file, obtain a secure descriptor to it.
    138      */
    139 
    140     if (repFile) {
    141     repFd = GetReplaceStream(caller, repFile);
    142     if (repFd < 0)
    143         bb_error_msg_and_die("unable to read replacement file");
    144     }
    145 
    146     /*
    147      * Change directory to our crontab directory
    148      */
    149 
    150     bb_xchdir(CDir);
    151 
    152     /*
    153      * Handle options as appropriate
    154      */
    155 
    156     switch(option) {
    157     case LIST:
    158     {
    159         FILE *fi;
    160         char buf[1024];
    161 
    162         if ((fi = fopen(pas->pw_name, "r"))) {
    163         while (fgets(buf, sizeof(buf), fi) != NULL)
    164             fputs(buf, stdout);
    165         fclose(fi);
    166         } else {
    167         bb_error_msg("no crontab for %s", pas->pw_name);
    168         }
    169     }
    170     break;
    171     case EDIT:
    172     {
    173         FILE *fi;
    174         int fd;
    175         int n;
    176         char tmp[128];
    177         char buf[1024];
    178 
    179         snprintf(tmp, sizeof(tmp), TMPDIR "/crontab.%d", getpid());
    180         fd = bb_xopen3(tmp, O_RDWR|O_CREAT|O_TRUNC|O_EXCL, 0600);
    181         chown(tmp, getuid(), getgid());
    182         if ((fi = fopen(pas->pw_name, "r"))) {
    183         while ((n = fread(buf, 1, sizeof(buf), fi)) > 0)
    184             write(fd, buf, n);
    185         }
    186         EditFile(caller, tmp);
    187         remove(tmp);
    188         lseek(fd, 0L, 0);
    189         repFd = fd;
    190     }
    191     option = REPLACE;
    192     /* fall through */
    193     case REPLACE:
    194     {
    195         char buf[1024];
    196         char path[1024];
    197         int fd;
    198         int n;
    199 
    200         snprintf(path, sizeof(path), "%s.new", pas->pw_name);
    201         if ((fd = open(path, O_CREAT|O_TRUNC|O_APPEND|O_WRONLY, 0600)) >= 0) {
    202         while ((n = read(repFd, buf, sizeof(buf))) > 0) {
    203             write(fd, buf, n);
    204         }
    205         close(fd);
    206         rename(path, pas->pw_name);
    207         } else {
    208         bb_error_msg("unable to create %s/%s", CDir, path);
    209         }
    210         close(repFd);
    211     }
    212     break;
    213     case DELETE:
    214     remove(pas->pw_name);
    215     break;
    216     case NONE:
    217     default:
    218     break;
    219     }
    220 
    221     /*
    222      *  Bump notification file.  Handle window where crond picks file up
    223      *  before we can write our entry out.
    224      */
    225 
    226     if (option == REPLACE || option == DELETE) {
    227     FILE *fo;
    228     struct stat st;
    229 
    230     while ((fo = fopen(CRONUPDATE, "a"))) {
    231         fprintf(fo, "%s\n", pas->pw_name);
    232         fflush(fo);
    233         if (fstat(fileno(fo), &st) != 0 || st.st_nlink != 0) {
    234         fclose(fo);
    235208        break;
    236         }
    237         fclose(fo);
    238         /* loop */
    239     }
    240     if (fo == NULL) {
    241         bb_error_msg("unable to append to %s/%s", CDir, CRONUPDATE);
    242     }
    243     }
    244     return 0;
     209    }
     210
     211    /*
     212     *  Bump notification file.  Handle window where crond picks file up
     213     *  before we can write our entry out.
     214     */
     215
     216    if (option == REPLACE || option == DELETE) {
     217        FILE *fo;
     218        struct stat st;
     219
     220        while ((fo = fopen(CRONUPDATE, "a"))) {
     221            fprintf(fo, "%s\n", pas->pw_name);
     222            fflush(fo);
     223            if (fstat(fileno(fo), &st) != 0 || st.st_nlink != 0) {
     224                fclose(fo);
     225                break;
     226            }
     227            fclose(fo);
     228            /* loop */
     229        }
     230        if (fo == NULL) {
     231            bb_error_msg("cannot append to %s/%s", CDir, CRONUPDATE);
     232        }
     233    }
     234    return 0;
    245235}
    246236
    247 static int
    248 GetReplaceStream(const char *user, const char *file)
     237static int GetReplaceStream(const char *user, const char *file)
    249238{
    250     int filedes[2];
    251     int pid;
    252     int fd;
    253     int n;
    254     char buf[1024];
    255 
    256     if (pipe(filedes) < 0) {
    257     perror("pipe");
    258     return(-1);
    259     }
    260     if ((pid = fork()) < 0) {
    261     perror("fork");
    262     return(-1);
    263     }
    264     if (pid > 0) {
    265     /*
    266      * PARENT
    267      */
    268 
    269     close(filedes[1]);
    270     if (read(filedes[0], buf, 1) != 1) {
    271         close(filedes[0]);
    272         filedes[0] = -1;
    273     }
    274     return(filedes[0]);
    275     }
    276 
    277     /*
    278      * CHILD
    279      */
    280 
    281     close(filedes[0]);
    282 
    283     if (ChangeUser(user, 0) < 0)
     239    int filedes[2];
     240    int pid;
     241    int fd;
     242    int n;
     243    char buf[1024];
     244
     245    if (pipe(filedes) < 0) {
     246        perror("pipe");
     247        return -1;
     248    }
     249    pid = fork();
     250    if (pid < 0) {
     251        perror("fork");
     252        return -1;
     253    }
     254    if (pid > 0) {
     255        /*
     256         * PARENT
     257         */
     258
     259        close(filedes[1]);
     260        if (read(filedes[0], buf, 1) != 1) {
     261            close(filedes[0]);
     262            filedes[0] = -1;
     263        }
     264        return filedes[0];
     265    }
     266
     267    /*
     268     * CHILD
     269     */
     270
     271    close(filedes[0]);
     272
     273    if (ChangeUser(user, 0) < 0)
     274        exit(0);
     275
     276    xfunc_error_retval = 0;
     277    fd = xopen(file, O_RDONLY);
     278    buf[0] = 0;
     279    write(filedes[1], buf, 1);
     280    while ((n = read(fd, buf, sizeof(buf))) > 0) {
     281        write(filedes[1], buf, n);
     282    }
    284283    exit(0);
    285 
    286     bb_default_error_retval = 0;
    287     fd = bb_xopen3(file, O_RDONLY, 0);
    288     buf[0] = 0;
    289     write(filedes[1], buf, 1);
    290     while ((n = read(fd, buf, sizeof(buf))) > 0) {
    291     write(filedes[1], buf, n);
    292     }
    293     exit(0);
    294284}
    295285
    296 static void
    297 EditFile(const char *user, const char *file)
     286static void EditFile(const char *user, const char *file)
    298287{
    299     int pid;
    300 
    301     if ((pid = fork()) == 0) {
    302     /*
    303      * CHILD - change user and run editor
    304      */
    305     char *ptr;
    306     char visual[1024];
    307 
    308     if (ChangeUser(user, 1) < 0)
    309         exit(0);
    310     if ((ptr = getenv("VISUAL")) == NULL || strlen(ptr) > 256)
    311         ptr = PATH_VI;
    312 
    313     snprintf(visual, sizeof(visual), "%s %s", ptr, file);
    314     execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", visual, NULL);
    315     perror("exec");
    316     exit(0);
    317     }
    318     if (pid < 0) {
    319     /*
    320      * PARENT - failure
    321      */
    322     bb_perror_msg_and_die("fork");
    323     }
    324     wait4(pid, NULL, 0, NULL);
     288    int pid = fork();
     289
     290    if (pid == 0) {
     291        /*
     292         * CHILD - change user and run editor
     293         */
     294        const char *ptr;
     295
     296        if (ChangeUser(user, 1) < 0)
     297            exit(0);
     298        ptr = getenv("VISUAL");
     299        if (ptr == NULL)
     300            ptr = getenv("EDITOR");
     301        if (ptr == NULL)
     302            ptr = PATH_VI;
     303
     304        ptr = xasprintf("%s %s", ptr, file);
     305        execl(DEFAULT_SHELL, DEFAULT_SHELL, "-c", ptr, NULL);
     306        bb_perror_msg_and_die("exec");
     307    }
     308    if (pid < 0) {
     309        /*
     310         * PARENT - failure
     311         */
     312        bb_perror_msg_and_die("fork");
     313    }
     314    wait4(pid, NULL, 0, NULL);
    325315}
    326316
    327 static int
    328 ChangeUser(const char *user, short dochdir)
     317static int ChangeUser(const char *user, short dochdir)
    329318{
    330     struct passwd *pas;
    331 
    332     /*
    333     * Obtain password entry and change privileges
    334     */
    335 
    336     if ((pas = getpwnam(user)) == NULL) {
    337     bb_perror_msg_and_die("failed to get uid for %s", user);
    338     return(-1);
    339     }
    340     setenv("USER", pas->pw_name, 1);
    341     setenv("HOME", pas->pw_dir, 1);
    342     setenv("SHELL", DEFAULT_SHELL, 1);
    343 
    344     /*
    345     * Change running state to the user in question
    346     */
    347     change_identity(pas);
    348 
    349     if (dochdir) {
    350     if (chdir(pas->pw_dir) < 0) {
    351         bb_perror_msg("chdir failed: %s %s", user, pas->pw_dir);
    352         bb_xchdir(TMPDIR);
    353     }
    354     }
    355     return(pas->pw_uid);
     319    struct passwd *pas;
     320
     321    /*
     322    * Obtain password entry and change privileges
     323    */
     324
     325    pas = getpwnam(user);
     326    if (pas == NULL) {
     327        bb_perror_msg_and_die("failed to get uid for %s", user);
     328    }
     329    setenv("USER", pas->pw_name, 1);
     330    setenv("HOME", pas->pw_dir, 1);
     331    setenv("SHELL", DEFAULT_SHELL, 1);
     332
     333    /*
     334    * Change running state to the user in question
     335    */
     336    change_identity(pas);
     337
     338    if (dochdir) {
     339        if (chdir(pas->pw_dir) < 0) {
     340            bb_perror_msg("chdir(%s) by %s failed", pas->pw_dir, user);
     341            xchdir(TMPDIR);
     342        }
     343    }
     344    return pas->pw_uid;
    356345}
  • branches/stable/mindi-busybox/miscutils/dc.c

    r821 r1770  
    11/* vi: set sw=4 ts=4: */
    2 #include "busybox.h"
    3 #include <ctype.h>
    4 #include <stdio.h>
    5 #include <stdlib.h>
    6 #include <string.h>
    7 #include <unistd.h>
     2/*
     3 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
     4 */
     5
     6#include "libbb.h"
    87#include <math.h>
    98
    109/* Tiny RPN calculator, because "expr" didn't give me bitwise operations. */
    1110
    12 static double stack[100];
     11enum { STACK_SIZE = COMMON_BUFSIZE / sizeof(double) };
     12
     13#define stack ((double*)&bb_common_bufsiz1)
    1314static unsigned int pointer;
    1415static unsigned char base;
     
    1617static void push(double a)
    1718{
    18     if (pointer >= (sizeof(stack) / sizeof(*stack)))
     19    if (pointer >= STACK_SIZE)
    1920        bb_error_msg_and_die("stack overflow");
    2021    stack[pointer++] = a;
     
    8889static void set_output_base(void)
    8990{
    90     base=(unsigned char)pop();
     91    base = (unsigned char)pop();
    9192    if ((base != 10) && (base != 16)) {
    92         fprintf(stderr, "Error: base = %d is not supported.\n", base);
    93         base=10;
     93        bb_error_msg("error, base %d is not supported", base);
     94        base = 10;
    9495    }
    9596}
     
    100101        printf("%x\n", (unsigned int)print);
    101102    else
    102     printf("%g\n", print);
     103        printf("%g\n", print);
    103104}
    104105
    105106static void print_stack_no_pop(void)
    106107{
    107     unsigned int i=pointer;
     108    unsigned int i = pointer;
    108109    while (i)
    109110        print_base(stack[--i]);
     
    116117
    117118struct op {
    118     const char *name;
     119    const char name[4];
    119120    void (*function) (void);
    120121};
     
    142143    {"f", print_stack_no_pop},
    143144    {"o", set_output_base},
    144     {0,    0}
     145    {"", 0}
    145146};
    146147
     
    161162    }
    162163
    163     while (o->name != 0) {
     164    while (o->name[0]) {
    164165        if (strcmp(o->name, argument) == 0) {
    165             (*(o->function)) ();
     166            o->function();
    166167            return;
    167168        }
    168169        o++;
    169170    }
    170     bb_error_msg_and_die("%s: syntax error.", argument);
     171    bb_error_msg_and_die("%s: syntax error", argument);
    171172}
    172173
     
    176177static char *get_token(char **buffer)
    177178{
    178     char *start   = NULL;
    179     char *current = *buffer;
    180 
    181     while (isspace(*current)) { current++; }
     179    char *start = NULL;
     180    char *current;
     181
     182    current = skip_whitespace(*buffer);
    182183    if (*current != 0) {
    183184        start = current;
    184         while (!isspace(*current) && *current != 0) { current++; }
     185        current = skip_non_whitespace(current);
    185186        *buffer = current;
    186187    }
     
    197198}
    198199
     200int dc_main(int argc, char **argv);
    199201int dc_main(int argc, char **argv)
    200202{
     
    205207        char *cursor = NULL;
    206208        char *token  = NULL;
    207         while ((line = bb_get_chomped_line_from_file(stdin))) {
     209        while ((line = xmalloc_getline(stdin))) {
    208210            cursor = line;
    209211            len = number_of_tokens(line);
     
    216218        }
    217219    } else {
    218         if (*argv[1]=='-')
     220        if (*argv[1] == '-')
    219221            bb_show_usage();
    220222        while (argc >= 2) {
  • branches/stable/mindi-busybox/miscutils/devfsd.c

    r821 r1770  
     1/* vi: set sw=4 ts=4: */
     2/*
     3 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
     4 */
     5
    16/*
    27    devfsd implementation for busybox
     
    5055*/
    5156
    52 #include "busybox.h"
    53 #include "xregex.h"
    54 #include <unistd.h>
    55 #include <stdio.h>
    56 #include <stdlib.h>
    57 #include <stdarg.h>
    58 #include <string.h>
    59 #include <ctype.h>
    60 #include <sys/stat.h>
    61 #include <sys/types.h>
    62 #include <sys/wait.h>
    63 #include <sys/ioctl.h>
    64 #include <sys/socket.h>
     57//#include <sys/wait.h>
     58//#include <sys/ioctl.h>
     59//#include <sys/socket.h>
    6560#include <sys/un.h>
    6661#include <dirent.h>
    67 #include <fcntl.h>
    6862#include <syslog.h>
    69 #include <signal.h>
    70 #include <errno.h>
    7163#include <sys/sysmacros.h>
     64#include "libbb.h"
     65#include "xregex.h"
    7266
    7367
     
    165159struct permissions_type
    166160{
    167     mode_t mode;
    168     uid_t uid;
    169     gid_t gid;
     161    mode_t mode;
     162    uid_t uid;
     163    gid_t gid;
    170164};
    171165
    172166struct execute_type
    173167{
    174     char *argv[MAX_ARGS + 1];  /*  argv[0] must always be the programme  */
     168    char *argv[MAX_ARGS + 1];  /*  argv[0] must always be the programme  */
    175169};
    176170
    177171struct copy_type
    178172{
    179     const char *source;
    180     const char *destination;
     173    const char *source;
     174    const char *destination;
    181175};
    182176
    183177struct action_type
    184178{
    185     unsigned int what;
    186     unsigned int when;
     179    unsigned int what;
     180    unsigned int when;
    187181};
    188182
    189183struct config_entry_struct
    190184{
    191     struct action_type action;
    192     regex_t preg;
    193     union
    194     {
     185    struct action_type action;
     186    regex_t preg;
     187    union
     188    {
    195189    struct permissions_type permissions;
    196190    struct execute_type execute;
    197191    struct copy_type copy;
    198     }
    199     u;
    200     struct config_entry_struct *next;
     192    }
     193    u;
     194    struct config_entry_struct *next;
    201195};
    202196
    203197struct get_variable_info
    204198{
    205     const struct devfsd_notify_struct *info;
    206     const char *devname;
    207     char devpath[STRING_LENGTH];
     199    const struct devfsd_notify_struct *info;
     200    const char *devname;
     201    char devpath[STRING_LENGTH];
    208202};
    209203
    210 static void dir_operation(int , const char * , int,  unsigned long* );
     204static void dir_operation(int , const char * , int,  unsigned long*);
    211205static void service(struct stat statbuf, char *path);
    212 static int st_expr_expand(char *, unsigned, const char *, const char *(*) (const char *, void *), void *);
     206static int st_expr_expand(char *, unsigned, const char *, const char *(*)(const char *, void *), void *);
    213207static const char *get_old_name(const char *, unsigned, char *, unsigned, unsigned);
    214 static int mksymlink (const char *oldpath, const char *newpath);
    215 static void read_config_file (char *path, int optional, unsigned long *event_mask);
    216 static void process_config_line (const char *, unsigned long *);
    217 static int  do_servicing (int, unsigned long);
    218 static void service_name (const struct devfsd_notify_struct *);
    219 static void action_permissions (const struct devfsd_notify_struct *, const struct config_entry_struct *);
    220 static void action_execute (const struct devfsd_notify_struct *, const struct config_entry_struct *,
     208static int mksymlink(const char *oldpath, const char *newpath);
     209static void read_config_file(char *path, int optional, unsigned long *event_mask);
     210static void process_config_line(const char *, unsigned long *);
     211static int  do_servicing(int, unsigned long);
     212static void service_name(const struct devfsd_notify_struct *);
     213static void action_permissions(const struct devfsd_notify_struct *, const struct config_entry_struct *);
     214static void action_execute(const struct devfsd_notify_struct *, const struct config_entry_struct *,
    221215                            const regmatch_t *, unsigned);
    222 static void action_modload (const struct devfsd_notify_struct *info, const struct config_entry_struct *entry);
    223 static void action_copy (const struct devfsd_notify_struct *, const struct config_entry_struct *,
     216static void action_modload(const struct devfsd_notify_struct *info, const struct config_entry_struct *entry);
     217static void action_copy(const struct devfsd_notify_struct *, const struct config_entry_struct *,
    224218                         const regmatch_t *, unsigned);
    225 static void action_compat (const struct devfsd_notify_struct *, unsigned);
    226 static void free_config (void);
     219static void action_compat(const struct devfsd_notify_struct *, unsigned);
     220static void free_config(void);
    227221static void restore(char *spath, struct stat source_stat, int rootlen);
    228 static int copy_inode (const char *, const struct stat *, mode_t, const char *, const struct stat *);
    229 static mode_t get_mode (const char *);
    230 static void signal_handler (int);
    231 static const char *get_variable (const char *, void *);
    232 static int make_dir_tree (const char *);
     222static int copy_inode(const char *, const struct stat *, mode_t, const char *, const struct stat *);
     223static mode_t get_mode(const char *);
     224static void signal_handler(int);
     225static const char *get_variable(const char *, void *);
     226static int make_dir_tree(const char *);
    233227static int expand_expression(char *, unsigned, const char *, const char *(*)(const char *, void *), void *,
    234                              const char *, const regmatch_t *, unsigned );
    235 static void expand_regexp (char *, size_t, const char *, const char *, const regmatch_t *, unsigned );
     228                             const char *, const regmatch_t *, unsigned);
     229static void expand_regexp(char *, size_t, const char *, const char *, const regmatch_t *, unsigned);
    236230static const char *expand_variable( char *, unsigned, unsigned *, const char *,
    237                                     const char *(*) (const char *, void *), void * );
    238 static const char *get_variable_v2(const char *, const char *(*) (const char *, void *), void *);
    239 static char get_old_ide_name (unsigned , unsigned);
    240 static char *write_old_sd_name (char *, unsigned, unsigned, char *);
     231                                    const char *(*)(const char *, void *), void *);
     232static const char *get_variable_v2(const char *, const char *(*)(const char *, void *), void *);
     233static char get_old_ide_name(unsigned , unsigned);
     234static char *write_old_sd_name(char *, unsigned, unsigned, const char *);
    241235
    242236/* busybox functions */
    243 static void msg_logger(int pri, const char * fmt, ... )__attribute__ ((format (printf, 2, 3)));
    244 static void msg_logger_and_die(int pri, const char * fmt, ... )__attribute__ ((noreturn, format (printf, 2, 3)));
    245 static void do_ioctl_and_die(int fd, int request, unsigned long event_mask_flag);
    246 static void fork_and_execute(int die, char *arg0, char **arg );
    247 static int get_uid_gid ( int, const char *);
    248 static void safe_memcpy( char * dest, const char * src, int len);
    249 static unsigned int scan_dev_name_common(const char *d, unsigned int n, int addendum, char *ptr);
    250 static unsigned int scan_dev_name(const char *d, unsigned int n, char *ptr);
     237static int get_uid_gid(int flag, const char *string);
     238static void safe_memcpy(char * dest, const char * src, int len);
     239static unsigned int scan_dev_name_common(const char *d, unsigned int n, int addendum, const char *ptr);
     240static unsigned int scan_dev_name(const char *d, unsigned int n, const char *ptr);
    251241
    252242/* Structs and vars */
    253243static struct config_entry_struct *first_config = NULL;
    254244static struct config_entry_struct *last_config = NULL;
    255 static const char *mount_point = NULL;
     245static char *mount_point = NULL;
    256246static volatile int caught_signal = FALSE;
    257247static volatile int caught_sighup = FALSE;
    258 static struct initial_symlink_struct
    259 {
    260     char *dest;
    261     char *name;
    262 } initial_symlinks[] =
    263 {
    264     {"/proc/self/fd", "fd"},
    265     {"fd/0", "stdin"},
    266     {"fd/1", "stdout"},
    267     {"fd/2", "stderr"},
    268     {NULL, NULL},
     248static struct initial_symlink_struct {
     249    const char *dest;
     250    const char *name;
     251} initial_symlinks[] = {
     252    {"/proc/self/fd", "fd"},
     253    {"fd/0", "stdin"},
     254    {"fd/1", "stdout"},
     255    {"fd/2", "stderr"},
     256    {NULL, NULL},
    269257};
    270258
    271 static struct event_type
    272 {
    273     unsigned int type;        /*  The DEVFSD_NOTIFY_* value                  */
    274     const char *config_name;  /*  The name used in the config file           */
    275 } event_types[] =
    276 {
    277     {DEVFSD_NOTIFY_REGISTERED,   "REGISTER"},
    278     {DEVFSD_NOTIFY_UNREGISTERED, "UNREGISTER"},
    279     {DEVFSD_NOTIFY_ASYNC_OPEN,   "ASYNC_OPEN"},
    280     {DEVFSD_NOTIFY_CLOSE,        "CLOSE"},
    281     {DEVFSD_NOTIFY_LOOKUP,       "LOOKUP"},
    282     {DEVFSD_NOTIFY_CHANGE,       "CHANGE"},
    283     {DEVFSD_NOTIFY_CREATE,       "CREATE"},
    284     {DEVFSD_NOTIFY_DELETE,       "DELETE"},
    285     {0xffffffff,                 NULL}
     259static struct event_type {
     260    unsigned int type;        /*  The DEVFSD_NOTIFY_* value                  */
     261    const char *config_name;  /*  The name used in the config file           */
     262} event_types[] = {
     263    {DEVFSD_NOTIFY_REGISTERED,   "REGISTER"},
     264    {DEVFSD_NOTIFY_UNREGISTERED, "UNREGISTER"},
     265    {DEVFSD_NOTIFY_ASYNC_OPEN,   "ASYNC_OPEN"},
     266    {DEVFSD_NOTIFY_CLOSE,        "CLOSE"},
     267    {DEVFSD_NOTIFY_LOOKUP,       "LOOKUP"},
     268    {DEVFSD_NOTIFY_CHANGE,       "CHANGE"},
     269    {DEVFSD_NOTIFY_CREATE,       "CREATE"},
     270    {DEVFSD_NOTIFY_DELETE,       "DELETE"},
     271    {0xffffffff,                 NULL}
    286272};
    287273
    288274/* Busybox messages */
    289275
    290 static const char * const bb_msg_proto_rev          = "protocol revision";
    291 static const char * const bb_msg_bad_config     = "bad %s config file: %s";
    292 static const char * const bb_msg_small_buffer       = "buffer too small";
    293 static const char * const bb_msg_variable_not_found = "variable: %s not found";
    294 
    295 /* Busybox functions  */
    296 static void msg_logger(int pri, const char * fmt, ... )
    297 {
    298     va_list ap;
    299     int ret;
    300 
    301     va_start(ap, fmt);
    302     ret = access ("/dev/log", F_OK);
    303     if (ret == 0) {
    304         openlog(bb_applet_name, 0, LOG_DAEMON);
    305         vsyslog( pri , fmt, ap);
    306         /* Man: A trailing newline is added when needed. */
    307         closelog();
    308     }
    309     /* ENABLE_DEVFSD_VERBOSE is always enabled if msg_logger is used */
    310     if ((ENABLE_DEVFSD_VERBOSE && ret) || ENABLE_DEBUG) {
    311         bb_error_msg(fmt, ap);
    312     }
    313     va_end(ap);
    314 }
    315 
    316 static void msg_logger_and_die(int pri, const char* fmt, ...)
    317 {
    318     va_list ap;
    319 
    320     va_start(ap, fmt);
    321     msg_logger(pri, fmt, ap);
    322     va_end(ap);
    323     exit(EXIT_FAILURE);
    324 }
     276static const char bb_msg_proto_rev[] ALIGN1          = "protocol revision";
     277static const char bb_msg_bad_config[] ALIGN1         = "bad %s config file: %s";
     278static const char bb_msg_small_buffer[] ALIGN1       = "buffer too small";
     279static const char bb_msg_variable_not_found[] ALIGN1 = "variable: %s not found";
    325280
    326281/* Busybox stuff */
    327 #if defined(CONFIG_DEVFSD_VERBOSE) || defined(CONFIG_DEBUG)
    328 #define devfsd_error_msg(fmt, args...)                bb_error_msg(fmt, ## args)
    329 #define devfsd_perror_msg_and_die(fmt, args...)       bb_perror_msg_and_die(fmt, ## args)
    330 #define devfsd_error_msg_and_die(fmt, args...)        bb_error_msg_and_die(fmt, ## args)
    331 #if defined(CONFIG_DEBUG)
    332 #define debug_msg_logger(x, fmt, args...)             msg_logger(x, fmt, ## args)
     282#if ENABLE_DEVFSD_VERBOSE || ENABLE_DEBUG
     283#define info_logger(p, fmt, args...)                 bb_info_msg(fmt, ## args)
     284#define msg_logger(p, fmt, args...)                  bb_error_msg(fmt, ## args)
     285#define msg_logger_and_die(p, fmt, args...)          bb_error_msg_and_die(fmt, ## args)
     286#define error_logger(p, fmt, args...)                bb_perror_msg(fmt, ## args)
     287#define error_logger_and_die(p, fmt, args...)        bb_perror_msg_and_die(fmt, ## args)
    333288#else
    334 #define debug_msg_logger(x, fmt, args...)
    335 #endif
    336 #else
    337 #define debug_msg_logger(x, fmt, args...)
     289#define info_logger(p, fmt, args...)
    338290#define msg_logger(p, fmt, args...)
    339291#define msg_logger_and_die(p, fmt, args...)           exit(1)
    340 #define devfsd_perror_msg_and_die(fmt, args...)       exit(1)
    341 #define devfsd_error_msg_and_die(fmt, args...)        exit(1)
    342 #define devfsd_error_msg(fmt, args...)
     292#define error_logger(p, fmt, args...)
     293#define error_logger_and_die(p, fmt, args...)         exit(1)
    343294#endif
    344295
    345 static void do_ioctl_and_die(int fd, int request, unsigned long event_mask_flag)
    346 {
    347     if (ioctl (fd, request, event_mask_flag) == -1)
    348         msg_logger_and_die(LOG_ERR, "ioctl");
    349 }
    350 
    351 static void fork_and_execute(int die, char *arg0, char **arg )
    352 {
    353     switch ( fork () )
    354     {
    355     case 0:
    356         /*  Child  */
    357         break;
    358     case -1:
    359         /*  Parent: Error  : die or return */
    360         msg_logger(LOG_ERR,(char *) bb_msg_memory_exhausted);
    361         if(die)
    362             exit(EXIT_FAILURE);
    363         return;
    364     default:
    365         /*  Parent : ok : return or exit  */
    366         if(arg0 != NULL)
    367         {
    368             wait (NULL);
    369             return;
    370         }
    371         exit (EXIT_SUCCESS);
    372     }
    373      /* Child : if arg0 != NULL do execvp */
    374     if(arg0 != NULL )
    375     {
    376         execvp (arg0, arg);
    377         msg_logger_and_die(LOG_ERR, "execvp");
    378     }
    379 }
    380 
    381 static void safe_memcpy( char *dest, const char *src, int len)
    382 {
    383     memcpy (dest , src , len );
     296static void safe_memcpy(char *dest, const char *src, int len)
     297{
     298    memcpy(dest , src, len);
    384299    dest[len] = '\0';
    385300}
    386301
    387 static unsigned int scan_dev_name_common(const char *d, unsigned int n, int addendum, char *ptr)
    388 {
    389     if( d[n - 4]=='d' && d[n - 3]=='i' && d[n - 2]=='s' && d[n - 1]=='c')
    390         return (2 + addendum);
    391     else if( d[n - 2]=='c' && d[n - 1]=='d')
    392         return (3 + addendum);
    393     else if(ptr[0]=='p' && ptr[1]=='a' && ptr[2]=='r' && ptr[3]=='t')
    394         return (4 + addendum);
    395     else if( ptr[n - 2]=='m' && ptr[n - 1]=='t')
    396         return (5 + addendum);
    397     else
    398         return 0;
     302static unsigned int scan_dev_name_common(const char *d, unsigned int n, int addendum, const char *ptr)
     303{
     304    if (d[n - 4] == 'd' && d[n - 3] == 'i' && d[n - 2] == 's' && d[n - 1] == 'c')
     305        return 2 + addendum;
     306    if (d[n - 2] == 'c' && d[n - 1] == 'd')
     307        return 3 + addendum;
     308    if (ptr[0] == 'p' && ptr[1] == 'a' && ptr[2] == 'r' && ptr[3] == 't')
     309        return 4 + addendum;
     310    if (ptr[n - 2] == 'm' && ptr[n - 1] == 't')
     311        return 5 + addendum;
     312    return 0;
    399313}
    400314
    401 static unsigned int scan_dev_name(const char *d, unsigned int n, char *ptr)
    402 {
    403     if(d[0]=='s' && d[1]=='c' && d[2]=='s' && d[3]=='i' && d[4]=='/')
    404     {
    405         if( d[n - 7]=='g' && d[n - 6]=='e' && d[n - 5]=='n' &&
    406             d[n - 4]=='e' && d[n - 3]=='r' && d[n - 2]=='i' &&
    407             d[n - 1]=='c' )
     315static unsigned int scan_dev_name(const char *d, unsigned int n, const char *ptr)
     316{
     317    if (d[0] == 's' && d[1] == 'c' && d[2] == 's' && d[3] == 'i' && d[4] == '/') {
     318        if (d[n - 7] == 'g' && d[n - 6] == 'e' && d[n - 5] == 'n'
     319            && d[n - 4] == 'e' && d[n - 3] == 'r' && d[n - 2] == 'i' && d[n - 1] == 'c'
     320        )
    408321            return 1;
    409322        return scan_dev_name_common(d, n, 0, ptr);
    410323    }
    411     else if(d[0]=='i' && d[1]=='d' && d[2]=='e' && d[3]=='/' &&
    412             d[4]=='h' && d[5]=='o' && d[6]=='s' && d[7]=='t')
    413     {
     324    if (d[0] == 'i' && d[1] == 'd' && d[2] == 'e' && d[3] == '/'
     325        && d[4] == 'h' && d[5] == 'o' && d[6] == 's' && d[7] == 't'
     326    )
    414327        return scan_dev_name_common(d, n, 4, ptr);
    415     }
    416     else if(d[0]=='s' && d[1]=='b' && d[2]=='p' && d[3]=='/')
    417     {
     328    if (d[0] == 's' && d[1] == 'b' && d[2] == 'p' && d[3] == '/')
    418329        return 10;
    419     }
    420     else if(d[0]=='v' && d[1]=='c' && d[2]=='c' && d[3]=='/')
    421     {
     330    if (d[0] == 'v' && d[1] == 'c' && d[2] == 'c' && d[3] == '/')
    422331        return 11;
    423     }
    424     else if(d[0]=='p' && d[1]=='t' && d[2]=='y' && d[3]=='/')
    425     {
     332    if (d[0] == 'p' && d[1] == 't' && d[2] == 'y' && d[3] == '/')
    426333        return 12;
    427     }
    428334    return 0;
    429335}
     
    431337/*  Public functions follow  */
    432338
    433 int devfsd_main (int argc, char **argv)
     339int devfsd_main(int argc, char **argv);
     340int devfsd_main(int argc, char **argv)
    434341{
    435342    int print_version = FALSE;
     
    445352        bb_show_usage();
    446353
    447     for (count = 2; count < argc; ++count)
    448     {
    449         if(argv[count][0] == '-')
    450         {
    451             if(argv[count][1]=='v' && !argv[count][2]) /* -v */
    452                     print_version = TRUE;
    453             else if(ENABLE_DEVFSD_FG_NP && argv[count][1]=='f'
    454                     && argv[count][2]=='g' && !argv[count][3]) /* -fg */
    455                     do_daemon = FALSE;
    456             else if(ENABLE_DEVFSD_FG_NP && argv[count][1]=='n'
    457                     && argv[count][2]=='p' && !argv[count][3]) /* -np */
    458                     no_polling = TRUE;
     354    for (count = 2; count < argc; ++count) {
     355        if (argv[count][0] == '-') {
     356            if (argv[count][1] == 'v' && !argv[count][2]) /* -v */
     357                print_version = TRUE;
     358            else if (ENABLE_DEVFSD_FG_NP && argv[count][1] == 'f'
     359             && argv[count][2] == 'g' && !argv[count][3]) /* -fg */
     360                do_daemon = FALSE;
     361            else if (ENABLE_DEVFSD_FG_NP && argv[count][1] == 'n'
     362             && argv[count][2] == 'p' && !argv[count][3]) /* -np */
     363                no_polling = TRUE;
    459364            else
    460365                bb_show_usage();
     
    462367    }
    463368
    464     /* strip last / from mount point, so we don't need to check for it later */
    465     while( argv[1][1]!='\0' && argv[1][strlen(argv[1])-1] == '/' )
    466         argv[1][strlen(argv[1]) -1] = '\0';
    467 
    468     mount_point = argv[1];
    469 
    470     if (chdir (mount_point) != 0)
    471         devfsd_perror_msg_and_die(mount_point);
    472 
    473     fd = bb_xopen (".devfsd", O_RDONLY);
    474 
    475     if (fcntl (fd, F_SETFD, FD_CLOEXEC) != 0)
    476         devfsd_perror_msg_and_die("FD_CLOEXEC");
    477 
    478     if (ioctl (fd, DEVFSDIOC_GET_PROTO_REV, &proto_rev) == -1)
    479         msg_logger_and_die(LOG_ERR, "ioctl");
     369    mount_point = bb_simplify_path(argv[1]);
     370
     371    xchdir(mount_point);
     372
     373    fd = xopen(".devfsd", O_RDONLY);
     374
     375    if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0)
     376        bb_perror_msg_and_die("FD_CLOEXEC");
     377
     378    xioctl(fd, DEVFSDIOC_GET_PROTO_REV, &proto_rev);
    480379
    481380    /*setup initial entries */
    482     for (curr = initial_symlinks; curr->dest != NULL; ++curr)
    483         symlink (curr->dest, curr->name);
     381    for (curr = initial_symlinks; curr->dest != NULL; ++curr)
     382        symlink(curr->dest, curr->name);
    484383
    485384    /* NB: The check for CONFIG_FILE is done in read_config_file() */
    486385
    487     if ( print_version  || (DEVFSD_PROTOCOL_REVISION_DAEMON != proto_rev) )
    488     {
    489         bb_printf( "%s v%s\nDaemon %s:\t%d\nKernel-side %s:\t%d\n",
    490                      bb_applet_name,DEVFSD_VERSION,bb_msg_proto_rev,
    491                      DEVFSD_PROTOCOL_REVISION_DAEMON,bb_msg_proto_rev, proto_rev);
     386    if (print_version || (DEVFSD_PROTOCOL_REVISION_DAEMON != proto_rev)) {
     387        printf("%s v%s\nDaemon %s:\t%d\nKernel-side %s:\t%d\n",
     388                applet_name, DEVFSD_VERSION, bb_msg_proto_rev,
     389                DEVFSD_PROTOCOL_REVISION_DAEMON, bb_msg_proto_rev, proto_rev);
    492390        if (DEVFSD_PROTOCOL_REVISION_DAEMON != proto_rev)
    493             bb_error_msg_and_die( "%s mismatch!",bb_msg_proto_rev);
     391            bb_error_msg_and_die("%s mismatch!", bb_msg_proto_rev);
    494392        exit(EXIT_SUCCESS); /* -v */
    495393    }
    496     /*  Tell kernel we are special (i.e. we get to see hidden entries)  */
    497     do_ioctl_and_die(fd, DEVFSDIOC_SET_EVENT_MASK, 0);
    498 
    499     sigemptyset (&new_action.sa_mask);
     394    /*  Tell kernel we are special(i.e. we get to see hidden entries)  */
     395    xioctl(fd, DEVFSDIOC_SET_EVENT_MASK, 0);
     396
     397    sigemptyset(&new_action.sa_mask);
    500398    new_action.sa_flags = 0;
    501399
    502400    /*  Set up SIGHUP and SIGUSR1 handlers  */
    503401    new_action.sa_handler = signal_handler;
    504     if (sigaction (SIGHUP, &new_action, NULL) != 0 || sigaction (SIGUSR1, &new_action, NULL) != 0 )
    505         devfsd_error_msg_and_die( "sigaction");
    506 
    507     bb_printf("%s v%s  started for %s\n",bb_applet_name, DEVFSD_VERSION, mount_point);
     402    if (sigaction(SIGHUP, &new_action, NULL) != 0 || sigaction(SIGUSR1, &new_action, NULL) != 0)
     403        bb_error_msg_and_die("sigaction");
     404
     405    printf("%s v%s  started for %s\n",applet_name, DEVFSD_VERSION, mount_point);
    508406
    509407    /*  Set umask so that mknod(2), open(2) and mkdir(2) have complete control over permissions  */
    510     umask (0);
    511     read_config_file (CONFIG_FILE, FALSE, &event_mask);
     408    umask(0);
     409    read_config_file((char*)CONFIG_FILE, FALSE, &event_mask);
    512410    /*  Do the scan before forking, so that boot scripts see the finished product  */
    513     dir_operation(SERVICE,mount_point,0,NULL);
     411    dir_operation(SERVICE, mount_point, 0, NULL);
    514412
    515413    if (ENABLE_DEVFSD_FG_NP && no_polling)
    516         exit (0);
    517     if (do_daemon)
    518     {
     414        exit(0);
     415
     416    if (ENABLE_DEVFSD_VERBOSE || ENABLE_DEBUG)
     417        logmode = LOGMODE_BOTH;
     418    else if (do_daemon == TRUE)
     419        logmode = LOGMODE_SYSLOG;
     420    /* This is the default */
     421    /*else
     422        logmode = LOGMODE_STDIO; */
     423
     424    if (do_daemon) {
    519425        /*  Release so that the child can grab it  */
    520         do_ioctl_and_die(fd, DEVFSDIOC_RELEASE_EVENT_QUEUE, 0);
    521         fork_and_execute(DIE, NULL, NULL);
    522         setsid ();        /*  Prevent hangups and become pgrp leader         */
    523     } else if(ENABLE_DEVFSD_FG_NP) {
    524         setpgid (0, 0);  /*  Become process group leader                    */
    525     }
    526 
    527     while (TRUE)
    528     {
    529         do_scan = do_servicing (fd, event_mask);
    530 
    531         free_config ();
    532         read_config_file (CONFIG_FILE, FALSE, &event_mask);
     426        xioctl(fd, DEVFSDIOC_RELEASE_EVENT_QUEUE, 0);
     427        bb_daemonize_or_rexec(0, argv);
     428    } else if (ENABLE_DEVFSD_FG_NP) {
     429        setpgid(0, 0);  /*  Become process group leader                    */
     430    }
     431
     432    while (TRUE) {
     433        do_scan = do_servicing(fd, event_mask);
     434
     435        free_config();
     436        read_config_file((char*)CONFIG_FILE, FALSE, &event_mask);
    533437        if (do_scan)
    534             dir_operation(SERVICE,mount_point,0,NULL);
    535     }
     438            dir_operation(SERVICE, mount_point, 0, NULL);
     439    }
     440    if (ENABLE_FEATURE_CLEAN_UP) free(mount_point);
    536441}   /*  End Function main  */
    537442
     
    539444/*  Private functions follow  */
    540445
    541 static void read_config_file (char *path, int optional, unsigned long *event_mask)
     446static void read_config_file(char *path, int optional, unsigned long *event_mask)
    542447/*  [SUMMARY] Read a configuration database.
    543448    <path> The path to read the database from. If this is a directory, all
    544     entries in that directory will be read (except hidden entries).
     449    entries in that directory will be read(except hidden entries).
    545450    <optional> If TRUE, the routine will silently ignore a missing config file.
    546451    <event_mask> The event mask is written here. This is not initialised.
     
    551456    FILE *fp;
    552457    char buf[STRING_LENGTH];
    553     char *line=NULL;
    554 
    555     debug_msg_logger(LOG_INFO, "%s: %s", __FUNCTION__, path);
    556 
    557     if (stat (path, &statbuf) == 0 )
    558     {
     458    char *line = NULL;
     459    char *p;
     460
     461    if (stat(path, &statbuf) == 0) {
    559462        /* Don't read 0 length files: ignored */
    560         /*if( statbuf.st_size == 0 )
     463        /*if (statbuf.st_size == 0)
    561464                return;*/
    562         if ( S_ISDIR (statbuf.st_mode) )
    563         {
    564             /* strip last / from dirname so we don't need to check for it later */
    565             while( path  && path[1]!='\0' && path[strlen(path)-1] == '/')
    566                 path[strlen(path) -1] = '\0';
    567 
    568             dir_operation(READ_CONFIG, path, 0, event_mask);
     465        if (S_ISDIR(statbuf.st_mode)) {
     466            p = bb_simplify_path(path);
     467            dir_operation(READ_CONFIG, p, 0, event_mask);
     468            free(p);
    569469            return;
    570470        }
    571         if ( ( fp = fopen (path, "r") ) != NULL )
    572         {
    573             while (fgets (buf, STRING_LENGTH, fp) != NULL)
    574             {
     471        if ((fp = fopen(path, "r")) != NULL) {
     472            while (fgets(buf, STRING_LENGTH, fp) != NULL) {
    575473                /*  Skip whitespace  */
    576                 for (line = buf; isspace (*line); ++line)
    577                     /*VOID*/;
    578                 if (line[0] == '\0' || line[0] == '#' )
     474                line = buf;
     475                line = skip_whitespace(line);
     476                if (line[0] == '\0' || line[0] == '#')
    579477                    continue;
    580                 process_config_line (line, event_mask);
     478                process_config_line(line, event_mask);
    581479            }
    582             fclose (fp);
     480            fclose(fp);
    583481        } else {
    584482            goto read_config_file_err;
     
    586484    } else {
    587485read_config_file_err:
    588     if(optional ==  0  && errno == ENOENT)
    589         msg_logger_and_die(LOG_ERR, "read config file: %s: %m", path);
    590     }
    591     return;
     486        if (optional == 0 && errno == ENOENT)
     487            error_logger_and_die(LOG_ERR, "read config file: %s", path);
     488    }
    592489}   /*  End Function read_config_file   */
    593490
    594 static void process_config_line (const char *line, unsigned long *event_mask)
     491static void process_config_line(const char *line, unsigned long *event_mask)
    595492/*  [SUMMARY] Process a line from a configuration file.
    596493    <line> The configuration line.
     
    604501    char when[STRING_LENGTH], what[STRING_LENGTH];
    605502    char name[STRING_LENGTH];
    606     char * msg="";
     503    const char *msg = "";
    607504    char *ptr;
    608505    int i;
    609506
    610507    /* !!!! Only Uppercase Keywords in devsfd.conf */
    611     static const char *const options[] = {
    612         "CLEAR_CONFIG", "INCLUDE", "OPTIONAL_INCLUDE",
    613         "RESTORE", "PERMISSIONS", "MODLOAD", "EXECUTE",
    614         "COPY", "IGNORE", "MKOLDCOMPAT", "MKNEWCOMPAT",
    615         "RMOLDCOMPAT", "RMNEWCOMPAT", 0
    616     };
    617 
    618     debug_msg_logger(LOG_INFO, __FUNCTION__);
    619 
    620     for (count = 0; count < MAX_ARGS; ++count) p[count][0] = '\0';
    621     num_args = sscanf (line, "%s %s %s %s %s %s %s %s %s %s",
     508    static const char options[] ALIGN1 =
     509        "CLEAR_CONFIG\0""INCLUDE\0""OPTIONAL_INCLUDE\0"
     510        "RESTORE\0""PERMISSIONS\0""MODLOAD\0""EXECUTE\0"
     511        "COPY\0""IGNORE\0""MKOLDCOMPAT\0""MKNEWCOMPAT\0"
     512        "RMOLDCOMPAT\0""RMNEWCOMPAT\0";
     513
     514    for (count = 0; count < MAX_ARGS; ++count)
     515        p[count][0] = '\0';
     516    num_args = sscanf(line, "%s %s %s %s %s %s %s %s %s %s",
    622517            when, name, what,
    623518            p[0], p[1], p[2], p[3], p[4], p[5], p[6]);
    624519
    625     i = compare_string_array(options, when );
    626 
    627     /*"CLEAR_CONFIG"*/
    628     if( i == 0)
    629     {
    630         free_config ();
     520    i = index_in_strings(options, when);
     521
     522    /* "CLEAR_CONFIG" */
     523    if (i == 0) {
     524        free_config();
    631525        *event_mask = 0;
    632526        return;
    633527    }
    634528
    635     if ( num_args < 2)
     529    if (num_args < 2)
    636530        goto process_config_line_err;
    637531
    638532    /* "INCLUDE" & "OPTIONAL_INCLUDE" */
    639     if( i == 1 || i == 2 )
    640     {
    641         st_expr_expand (name, STRING_LENGTH, name, get_variable, NULL );
    642         msg_logger(LOG_INFO, "%sinclude: %s",(toupper (when[0]) == 'I') ? "": "optional_", name);
    643         read_config_file (name, (toupper (when[0]) == 'I') ? FALSE : TRUE, event_mask);
     533    if (i == 1 || i == 2) {
     534        st_expr_expand(name, STRING_LENGTH, name, get_variable, NULL);
     535        info_logger(LOG_INFO, "%sinclude: %s", (toupper(when[0]) == 'I') ? "": "optional_", name);
     536        read_config_file(name, (toupper(when[0]) == 'I') ? FALSE : TRUE, event_mask);
    644537        return;
    645538    }
    646539    /* "RESTORE" */
    647     if( i == 3)
    648     {
    649         dir_operation(RESTORE,name, strlen (name),NULL);
     540    if (i == 3) {
     541        dir_operation(RESTORE, name, strlen(name),NULL);
    650542        return;
    651543    }
     
    653545        goto process_config_line_err;
    654546
    655     new = xmalloc (sizeof *new);
    656     memset (new, 0, sizeof *new);
    657 
    658     for (count = 0; event_types[count].config_name != NULL; ++count)
    659     {
    660         if (strcasecmp (when, event_types[count].config_name) != 0)
     547    new = xzalloc(sizeof *new);
     548
     549    for (count = 0; event_types[count].config_name != NULL; ++count) {
     550        if (strcasecmp(when, event_types[count].config_name) != 0)
    661551            continue;
    662552        new->action.when = event_types[count].type;
    663553        break;
    664554    }
    665     if (event_types[count].config_name == NULL)
    666     {
    667         msg="WHEN in";
     555    if (event_types[count].config_name == NULL) {
     556        msg = "WHEN in";
    668557        goto process_config_line_err;
    669558    }
    670559
    671     i = compare_string_array(options, what );
    672 
    673     switch(i)
    674     {
     560    i = index_in_strings(options, what);
     561
     562    switch (i) {
    675563        case 4: /* "PERMISSIONS" */
    676564            new->action.what = AC_PERMISSIONS;
    677565            /*  Get user and group  */
    678             if ( ( ptr = strchr (p[0], '.') ) == NULL )
    679             {
    680                 msg="UID.GID";
     566            if ((ptr = strchr(p[0], '.')) == NULL) {
     567                msg = "UID.GID";
    681568                goto process_config_line_err; /*"missing '.' in UID.GID"*/
    682569            }
    683570
    684571            *ptr++ = '\0';
    685             new->u.permissions.uid = get_uid_gid (UID, p[0]);
    686             new->u.permissions.gid = get_uid_gid (GID, ptr);
     572            new->u.permissions.uid = get_uid_gid(UID, p[0]);
     573            new->u.permissions.gid = get_uid_gid(GID, ptr);
    687574            /*  Get mode  */
    688             new->u.permissions.mode = get_mode (p[1]);
     575            new->u.permissions.mode = get_mode(p[1]);
    689576            break;
    690577        case 5: /*  MODLOAD */
    691             /*This  action will pass "/dev/$devname" (i.e. "/dev/" prefixed to
     578            /*This  action will pass "/dev/$devname"(i.e. "/dev/" prefixed to
    692579            the device name) to the module loading  facility.  In  addition,
    693580            the /etc/modules.devfs configuration file is used.*/
     
    700587
    701588            for (count = 0; count < num_args; ++count)
    702                 new->u.execute.argv[count] = bb_xstrdup (p[count]);
     589                new->u.execute.argv[count] = xstrdup(p[count]);
    703590
    704591            new->u.execute.argv[num_args] = NULL;
     
    710597                goto process_config_line_err; /* missing path and function in line */
    711598
    712             new->u.copy.source = bb_xstrdup (p[0]);
    713             new->u.copy.destination = bb_xstrdup (p[1]);
     599            new->u.copy.source = xstrdup(p[0]);
     600            new->u.copy.destination = xstrdup(p[1]);
    714601            break;
    715602        case 8: /* IGNORE */
     
    730617            break;
    731618        default:
    732             msg ="WHAT in";
     619            msg = "WHAT in";
    733620            goto process_config_line_err;
    734621        /*esac*/
    735622    } /* switch (i) */
    736623
    737     xregcomp( &new->preg, name, REG_EXTENDED);
     624    xregcomp(&new->preg, name, REG_EXTENDED);
    738625
    739626    *event_mask |= 1 << new->action.when;
     
    745632    last_config = new;
    746633    return;
    747 process_config_line_err:
     634
     635 process_config_line_err:
    748636    msg_logger_and_die(LOG_ERR, bb_msg_bad_config, msg , line);
    749637}  /*  End Function process_config_line   */
    750638
    751 static int do_servicing (int fd, unsigned long event_mask)
     639static int do_servicing(int fd, unsigned long event_mask)
    752640/*  [SUMMARY] Service devfs changes until a signal is received.
    753641    <fd> The open control file.
     
    758646    ssize_t bytes;
    759647    struct devfsd_notify_struct info;
    760     unsigned long tmp_event_mask;
    761 
    762     debug_msg_logger(LOG_INFO, __FUNCTION__);
    763 
    764     /*  Tell devfs what events we care about  */
    765     tmp_event_mask = event_mask;
    766     do_ioctl_and_die(fd, DEVFSDIOC_SET_EVENT_MASK, tmp_event_mask);
    767     while (!caught_signal)
    768     {
     648
     649    /* (void*) cast is only in order to match prototype */
     650    xioctl(fd, DEVFSDIOC_SET_EVENT_MASK, (void*)event_mask);
     651    while (!caught_signal) {
    769652        errno = 0;
    770         bytes = read (fd, (char *) &info, sizeof info);
     653        bytes = read(fd,(char *) &info, sizeof info);
    771654        if (caught_signal)
    772655            break;      /*  Must test for this first     */
     
    775658        if (bytes < 1)
    776659            break;
    777         service_name (&info);
    778     }
    779     if (caught_signal)
    780     {
     660        service_name(&info);
     661    }
     662    if (caught_signal) {
    781663        int c_sighup = caught_sighup;
    782664
    783665        caught_signal = FALSE;
    784666        caught_sighup = FALSE;
    785         return (c_sighup);
     667        return c_sighup;
    786668    }
    787669    msg_logger_and_die(LOG_ERR, "read error on control file");
    788670}   /*  End Function do_servicing  */
    789671
    790 static void service_name (const struct devfsd_notify_struct *info)
     672static void service_name(const struct devfsd_notify_struct *info)
    791673/*  [SUMMARY] Service a single devfs change.
    792674    <info> The devfs change.
     
    798680    struct config_entry_struct *entry;
    799681
    800     debug_msg_logger(LOG_INFO, __FUNCTION__);
    801682    if (ENABLE_DEBUG && info->overrun_count > 0)
    802         debug_msg_logger(LOG_ERR, "lost %u events", info->overrun_count);
     683        msg_logger(LOG_ERR, "lost %u events", info->overrun_count);
    803684
    804685    /*  Discard lookups on "/dev/log" and "/dev/initctl"  */
    805     if(   info->type == DEVFSD_NOTIFY_LOOKUP &&
    806         ((info->devname[0]=='l' && info->devname[1]=='o' &&
    807           info->devname[2]=='g' && !info->devname[3]) ||
    808         ( info->devname[0]=='i' && info->devname[1]=='n' &&
    809           info->devname[2]=='i' && info->devname[3]=='t' &&
    810           info->devname[4]=='c' && info->devname[5]=='t' &&
    811           info->devname[6]=='l' && !info->devname[7])))
    812             return;
    813     for (entry = first_config; entry != NULL; entry = entry->next)
    814     {
     686    if (info->type == DEVFSD_NOTIFY_LOOKUP
     687        && ((info->devname[0] == 'l' && info->devname[1] == 'o'
     688        && info->devname[2] == 'g' && !info->devname[3])
     689        || (info->devname[0] == 'i' && info->devname[1] == 'n'
     690        && info->devname[2] == 'i' && info->devname[3] == 't'
     691        && info->devname[4] == 'c' && info->devname[5] == 't'
     692        && info->devname[6] == 'l' && !info->devname[7]))
     693    )
     694        return;
     695
     696    for (entry = first_config; entry != NULL; entry = entry->next) {
    815697        /*  First check if action matches the type, then check if name matches */
    816         if (info->type != entry->action.when || regexec (&entry->preg, info->devname, MAX_SUBEXPR, mbuf, 0) != 0 )
     698        if (info->type != entry->action.when
     699        || regexec(&entry->preg, info->devname, MAX_SUBEXPR, mbuf, 0) != 0)
    817700            continue;
    818         for (n = 0; (n < MAX_SUBEXPR) && (mbuf[n].rm_so != -1); ++n)
     701        for (n = 0;(n < MAX_SUBEXPR) && (mbuf[n].rm_so != -1); ++n)
    819702            /* VOID */;
    820703
    821         debug_msg_logger(LOG_INFO, "%s: action.what %d", __FUNCTION__, entry->action.what);
    822 
    823         switch (entry->action.what)
    824         {
     704        switch (entry->action.what) {
    825705            case AC_PERMISSIONS:
    826                 action_permissions (info, entry);
     706                action_permissions(info, entry);
    827707                break;
    828708            case AC_MODLOAD:
    829                 if(ENABLE_DEVFSD_MODLOAD)
    830                     action_modload (info, entry);
     709                if (ENABLE_DEVFSD_MODLOAD)
     710                    action_modload(info, entry);
    831711                break;
    832712            case AC_EXECUTE:
    833                 action_execute (info, entry, mbuf, n);
     713                action_execute(info, entry, mbuf, n);
    834714                break;
    835715            case AC_COPY:
    836                 action_copy (info, entry, mbuf, n);
     716                action_copy(info, entry, mbuf, n);
    837717                break;
    838718            case AC_IGNORE:
     
    843723            case AC_RMOLDCOMPAT:
    844724            case AC_RMNEWCOMPAT:
    845                 action_compat (info, entry->action.what);
     725                action_compat(info, entry->action.what);
    846726                break;
    847727            default:
     
    851731}   /*  End Function service_name  */
    852732
    853 static void action_permissions (const struct devfsd_notify_struct *info,
     733static void action_permissions(const struct devfsd_notify_struct *info,
    854734                const struct config_entry_struct *entry)
    855735/*  [SUMMARY] Update permissions for a device entry.
     
    861741    struct stat statbuf;
    862742
    863     debug_msg_logger(LOG_INFO, __FUNCTION__);
    864 
    865     if ( stat (info->devname, &statbuf) != 0    ||
    866          chmod (info->devname,(statbuf.st_mode & S_IFMT) | (entry->u.permissions.mode & ~S_IFMT)) != 0 ||
    867          chown (info->devname, entry->u.permissions.uid, entry->u.permissions.gid) != 0)
    868     {
    869         msg_logger(LOG_ERR, "Can't chmod or chown: %s: %m",info->devname);
    870     }
     743    if (stat(info->devname, &statbuf) != 0
     744     || chmod(info->devname, (statbuf.st_mode & S_IFMT) | (entry->u.permissions.mode & ~S_IFMT)) != 0
     745     || chown(info->devname, entry->u.permissions.uid, entry->u.permissions.gid) != 0
     746    )
     747        error_logger(LOG_ERR, "Can't chmod or chown: %s", info->devname);
    871748}   /*  End Function action_permissions  */
    872749
    873 static void action_modload (const struct devfsd_notify_struct *info,
     750static void action_modload(const struct devfsd_notify_struct *info,
    874751                const struct config_entry_struct *entry ATTRIBUTE_UNUSED)
    875752/*  [SUMMARY] Load a module.
     
    880757{
    881758    char *argv[6];
    882     char device[STRING_LENGTH];
    883 
    884     argv[0] = MODPROBE;
    885     argv[1] = MODPROBE_SWITCH_1; /* "-k" */
    886     argv[2] = MODPROBE_SWITCH_2; /* "-C" */
    887     argv[3] = CONFIG_MODULES_DEVFS;
    888     argv[4] = device;
     759
     760    argv[0] = (char*)MODPROBE;
     761    argv[1] = (char*)MODPROBE_SWITCH_1; /* "-k" */
     762    argv[2] = (char*)MODPROBE_SWITCH_2; /* "-C" */
     763    argv[3] = (char*)CONFIG_MODULES_DEVFS;
     764    argv[4] = concat_path_file("/dev", info->devname); /* device */
    889765    argv[5] = NULL;
    890766
    891     snprintf (device, sizeof (device), "/dev/%s", info->devname);
    892     debug_msg_logger(LOG_INFO, "%s: %s %s %s %s %s",__FUNCTION__, argv[0],argv[1],argv[2],argv[3],argv[4]);
    893     fork_and_execute(DIE, argv[0], argv);
     767    wait4pid(xspawn(argv));
     768    free(argv[4]);
    894769}  /*  End Function action_modload  */
    895770
    896 static void action_execute (const struct devfsd_notify_struct *info,
     771static void action_execute(const struct devfsd_notify_struct *info,
    897772                const struct config_entry_struct *entry,
    898773                const regmatch_t *regexpr, unsigned int numexpr)
     
    900775    <info> The devfs change.
    901776    <entry> The config file entry.
    902     <regexpr> The number of subexpression (start, end) offsets within the
     777    <regexpr> The number of subexpression(start, end) offsets within the
    903778    device name.
    904779    <numexpr> The number of elements within <<regexpr>>.
     
    911786    char largv[MAX_ARGS + 1][STRING_LENGTH];
    912787
    913     debug_msg_logger(LOG_INFO ,__FUNCTION__);
    914788    gv_info.info = info;
    915789    gv_info.devname = info->devname;
    916     snprintf (gv_info.devpath, sizeof (gv_info.devpath), "%s/%s", mount_point, info->devname);
    917     for (count = 0; entry->u.execute.argv[count] != NULL; ++count)
    918     {
    919         expand_expression (largv[count], STRING_LENGTH,
     790    snprintf(gv_info.devpath, sizeof(gv_info.devpath), "%s/%s", mount_point, info->devname);
     791    for (count = 0; entry->u.execute.argv[count] != NULL; ++count) {
     792        expand_expression(largv[count], STRING_LENGTH,
    920793                entry->u.execute.argv[count],
    921794                get_variable, &gv_info,
    922                 gv_info.devname, regexpr, numexpr );
     795                gv_info.devname, regexpr, numexpr);
    923796        argv[count] = largv[count];
    924797    }
    925798    argv[count] = NULL;
    926     fork_and_execute(NO_DIE, argv[0], argv);
     799    wait4pid(spawn(argv));
    927800}   /*  End Function action_execute  */
    928801
    929802
    930 static void action_copy (const struct devfsd_notify_struct *info,
     803static void action_copy(const struct devfsd_notify_struct *info,
    931804             const struct config_entry_struct *entry,
    932805             const regmatch_t *regexpr, unsigned int numexpr)
     
    934807    <info> The devfs change.
    935808    <entry> The config file entry.
    936     <regexpr> This list of subexpression (start, end) offsets within the
     809    <regexpr> This list of subexpression(start, end) offsets within the
    937810    device name.
    938811    <numexpr> The number of elements in <<regexpr>>.
     
    946819    int ret = 0;
    947820
    948     debug_msg_logger(LOG_INFO, __FUNCTION__);
    949 
    950821    dest_stat.st_mode = 0;
    951822
    952     if ( (info->type == DEVFSD_NOTIFY_CHANGE) && S_ISLNK (info->mode) )
     823    if ((info->type == DEVFSD_NOTIFY_CHANGE) && S_ISLNK(info->mode))
    953824        return;
    954825    gv_info.info = info;
    955826    gv_info.devname = info->devname;
    956827
    957     snprintf (gv_info.devpath, sizeof (gv_info.devpath), "%s/%s", mount_point, info->devname);
    958     expand_expression (source, STRING_LENGTH, entry->u.copy.source,
     828    snprintf(gv_info.devpath, sizeof(gv_info.devpath), "%s/%s", mount_point, info->devname);
     829    expand_expression(source, STRING_LENGTH, entry->u.copy.source,
    959830                get_variable, &gv_info, gv_info.devname,
    960831                regexpr, numexpr);
    961832
    962     expand_expression (destination, STRING_LENGTH, entry->u.copy.destination,
     833    expand_expression(destination, STRING_LENGTH, entry->u.copy.destination,
    963834                get_variable, &gv_info, gv_info.devname,
    964835                regexpr, numexpr);
    965836
    966     if ( !make_dir_tree (destination) || lstat (source, &source_stat) != 0)
     837    if (!make_dir_tree(destination) || lstat(source, &source_stat) != 0)
    967838            return;
    968     lstat (destination, &dest_stat);
     839    lstat(destination, &dest_stat);
    969840    new_mode = source_stat.st_mode & ~S_ISVTX;
    970841    if (info->type == DEVFSD_NOTIFY_CREATE)
    971842        new_mode |= S_ISVTX;
    972     else if ( (info->type == DEVFSD_NOTIFY_CHANGE) && (dest_stat.st_mode & S_ISVTX) )
     843    else if ((info->type == DEVFSD_NOTIFY_CHANGE) &&(dest_stat.st_mode & S_ISVTX))
    973844        new_mode |= S_ISVTX;
    974     ret = copy_inode (destination, &dest_stat, new_mode, source, &source_stat);
     845    ret = copy_inode(destination, &dest_stat, new_mode, source, &source_stat);
    975846    if (ENABLE_DEBUG && ret && (errno != EEXIST))
    976         debug_msg_logger(LOG_ERR, "copy_inode: %s to %s: %m", source, destination);
    977     return;
     847        error_logger(LOG_ERR, "copy_inode: %s to %s", source, destination);
    978848}   /*  End Function action_copy  */
    979849
    980 static void action_compat (const struct devfsd_notify_struct *info, unsigned int action)
     850static void action_compat(const struct devfsd_notify_struct *info, unsigned int action)
    981851/*  [SUMMARY] Process a compatibility request.
    982852    <info> The devfs change.
     
    988858    const char *compat_name = NULL;
    989859    const char *dest_name = info->devname;
    990     char *ptr=NULL;
     860    const char *ptr;
    991861    char compat_buf[STRING_LENGTH], dest_buf[STRING_LENGTH];
    992862    int mode, host, bus, target, lun;
     
    1009879
    1010880    /*  First construct compatibility name  */
    1011     switch (action)
    1012     {
     881    switch (action) {
    1013882        case AC_MKOLDCOMPAT:
    1014883        case AC_RMOLDCOMPAT:
    1015             compat_name = get_old_name (info->devname, info->namelen, compat_buf, info->major, info->minor);
     884            compat_name = get_old_name(info->devname, info->namelen, compat_buf, info->major, info->minor);
    1016885            break;
    1017886        case AC_MKNEWCOMPAT:
    1018887        case AC_RMNEWCOMPAT:
    1019             ptr = strrchr (info->devname, '/') + 1;
    1020             i=scan_dev_name(info->devname, info->namelen, ptr);
    1021 
    1022             debug_msg_logger(LOG_INFO, "%s: scan_dev_name = %d", __FUNCTION__, i);
     888            ptr = bb_basename(info->devname);
     889            i = scan_dev_name(info->devname, info->namelen, ptr);
    1023890
    1024891            /* nothing found */
    1025             if(i==0 || i > 9)
     892            if (i == 0 || i > 9)
    1026893                return;
    1027894
    1028             sscanf (info->devname +((i<6)?5:4), "host%d/bus%d/target%d/lun%d/", &host, &bus, &target, &lun);
    1029             snprintf (dest_buf, sizeof (dest_buf), "../%s", info->devname + ((i>5)?4:0));
     895            sscanf(info->devname + ((i < 6) ? 5 : 4), "host%d/bus%d/target%d/lun%d/", &host, &bus, &target, &lun);
     896            snprintf(dest_buf, sizeof(dest_buf), "../%s", info->devname + (( i > 5) ? 4 : 0));
    1030897            dest_name = dest_buf;
    1031898            compat_name = compat_buf;
     
    1033900
    1034901            /* 1 == scsi/generic  2 == scsi/disc 3 == scsi/cd 6 == ide/host/disc 7 == ide/host/cd */
    1035             if( i == 1 || i == 2 || i == 3 || i == 6 || i ==7 )
    1036                 sprintf ( compat_buf, fmt[i], host, bus, target, lun);
     902            if (i == 1 || i == 2 || i == 3 || i == 6 || i ==7)
     903                sprintf(compat_buf, fmt[i], host, bus, target, lun);
    1037904
    1038905            /* 4 == scsi/part 8 == ide/host/part */
    1039             if( i == 4 || i == 8)
    1040                 sprintf ( compat_buf, fmt[i], host, bus, target, lun, atoi (ptr + 4) );
     906            if (i == 4 || i == 8)
     907                sprintf(compat_buf, fmt[i], host, bus, target, lun, atoi(ptr + 4));
    1041908
    1042909            /* 5 == scsi/mt */
    1043             if( i == 5)
    1044             {
     910            if (i == 5) {
    1045911                rewind_ = info->devname[info->namelen - 1];
    1046912                if (rewind_ != 'n')
    1047913                    rewind_ = '\0';
    1048914                mode=0;
    1049                 if(ptr[2] ==  'l' /*108*/ || ptr[2] == 'm'/*109*/)
     915                if (ptr[2] ==  'l' /*108*/ || ptr[2] == 'm'/*109*/)
    1050916                    mode = ptr[2] - 107; /* 1 or 2 */
    1051                 if(ptr[2] ==  'a')
     917                if (ptr[2] ==  'a')
    1052918                    mode = 3;
    1053                 sprintf (compat_buf, fmt [i], host, bus, target, lun, mode, rewind_);
     919                sprintf(compat_buf, fmt[i], host, bus, target, lun, mode, rewind_);
    1054920            }
    1055921
    1056922            /* 9 == ide/host/mt */
    1057             if( i ==  9 )
    1058                 snprintf (compat_buf, sizeof (compat_buf), fmt[i], host, bus, target, lun, ptr + 2);
     923            if (i ==  9)
     924                snprintf(compat_buf, sizeof(compat_buf), fmt[i], host, bus, target, lun, ptr + 2);
    1059925        /* esac */
    1060     } /* switch(action) */
    1061 
    1062     if(compat_name == NULL )
     926    } /* switch (action) */
     927
     928    if (compat_name == NULL)
    1063929        return;
    1064930
    1065     debug_msg_logger( LOG_INFO, "%s: %s", __FUNCTION__, compat_name);
    1066 
    1067931    /*  Now decide what to do with it  */
    1068     switch (action)
    1069     {
     932    switch (action) {
    1070933        case AC_MKOLDCOMPAT:
    1071934        case AC_MKNEWCOMPAT:
    1072             mksymlink (dest_name, compat_name);
     935            mksymlink(dest_name, compat_name);
    1073936            break;
    1074937        case AC_RMOLDCOMPAT:
    1075938        case AC_RMNEWCOMPAT:
    1076             ret = unlink (compat_name);
     939            ret = unlink(compat_name);
    1077940            if (ENABLE_DEBUG && ret)
    1078                 debug_msg_logger(LOG_ERR, "unlink: %s: %m", compat_name);
     941                error_logger(LOG_ERR, "unlink: %s", compat_name);
    1079942            break;
    1080943        /*esac*/
    1081     } /* switch(action) */
     944    } /* switch (action) */
    1082945}   /*  End Function action_compat  */
    1083946
    1084947static void restore(char *spath, struct stat source_stat, int rootlen)
    1085948{
    1086     char dpath[STRING_LENGTH];
     949    char *dpath;
    1087950    struct stat dest_stat;
    1088951
    1089     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1090 
    1091952    dest_stat.st_mode = 0;
    1092     snprintf (dpath, sizeof dpath, "%s%s", mount_point, spath + rootlen);
    1093     lstat (dpath, &dest_stat);
    1094 
    1095     if ( S_ISLNK (source_stat.st_mode) || (source_stat.st_mode & S_ISVTX) )
    1096         copy_inode (dpath, &dest_stat, (source_stat.st_mode & ~S_ISVTX) , spath, &source_stat);
    1097 
    1098     if ( S_ISDIR (source_stat.st_mode) )
     953    dpath = concat_path_file(mount_point, spath + rootlen);
     954    lstat(dpath, &dest_stat);
     955    free(dpath);
     956    if (S_ISLNK(source_stat.st_mode) || (source_stat.st_mode & S_ISVTX))
     957        copy_inode(dpath, &dest_stat,(source_stat.st_mode & ~S_ISVTX) , spath, &source_stat);
     958
     959    if (S_ISDIR(source_stat.st_mode))
    1099960        dir_operation(RESTORE, spath, rootlen,NULL);
    1100961}
    1101962
    1102963
    1103 static int copy_inode (const char *destpath, const struct stat *dest_stat,
     964static int copy_inode(const char *destpath, const struct stat *dest_stat,
    1104965            mode_t new_mode,
    1105966            const char *sourcepath, const struct stat *source_stat)
     
    1119980    char symlink_val[STRING_LENGTH];
    1120981
    1121     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1122 
    1123     if ( (source_stat->st_mode & S_IFMT) == (dest_stat->st_mode & S_IFMT) )
    1124     {
     982    if ((source_stat->st_mode & S_IFMT) ==(dest_stat->st_mode & S_IFMT)) {
    1125983        /*  Same type  */
    1126         if ( S_ISLNK (source_stat->st_mode) )
    1127         {
    1128             if (( source_len = readlink (sourcepath, source_link, STRING_LENGTH - 1) ) < 0 ||
    1129                 ( dest_len   = readlink (destpath  , dest_link  , STRING_LENGTH - 1) ) < 0 )
    1130                 return (FALSE);
     984        if (S_ISLNK(source_stat->st_mode)) {
     985            if ((source_len = readlink(sourcepath, source_link, STRING_LENGTH - 1)) < 0
     986                || (dest_len   = readlink(destpath  , dest_link  , STRING_LENGTH - 1)) < 0
     987            )
     988                return FALSE;
    1131989            source_link[source_len] = '\0';
    1132990            dest_link[dest_len] = '\0';
    1133             if ( (source_len != dest_len) || (strcmp (source_link, dest_link) != 0) )
    1134             {
    1135                 unlink (destpath);
    1136                 symlink (source_link, destpath);
     991            if ((source_len != dest_len) || (strcmp(source_link, dest_link) != 0)) {
     992                unlink(destpath);
     993                symlink(source_link, destpath);
    1137994            }
    1138             return (TRUE);
     995            return TRUE;
    1139996        }   /*  Else not a symlink  */
    1140         chmod (destpath, new_mode & ~S_IFMT);
    1141         chown (destpath, source_stat->st_uid, source_stat->st_gid);
    1142         return (TRUE);
     997        chmod(destpath, new_mode & ~S_IFMT);
     998        chown(destpath, source_stat->st_uid, source_stat->st_gid);
     999        return TRUE;
    11431000    }
    11441001    /*  Different types: unlink and create  */
    1145     unlink (destpath);
    1146     switch (source_stat->st_mode & S_IFMT)
    1147     {
     1002    unlink(destpath);
     1003    switch (source_stat->st_mode & S_IFMT) {
    11481004        case S_IFSOCK:
    1149             if ( ( fd = socket (AF_UNIX, SOCK_STREAM, 0) ) < 0 )
     1005            if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
    11501006                break;
    11511007            un_addr.sun_family = AF_UNIX;
    1152             snprintf (un_addr.sun_path, sizeof (un_addr.sun_path), "%s", destpath);
    1153             val = bind (fd, (struct sockaddr *) &un_addr, (int) sizeof un_addr);
    1154             close (fd);
    1155             if (val != 0 || chmod (destpath, new_mode & ~S_IFMT) != 0)
     1008            snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s", destpath);
     1009            val = bind(fd,(struct sockaddr *) &un_addr,(int) sizeof un_addr);
     1010            close(fd);
     1011            if (val != 0 || chmod(destpath, new_mode & ~S_IFMT) != 0)
    11561012                break;
    11571013            goto do_chown;
    11581014        case S_IFLNK:
    1159             if ( ( val = readlink (sourcepath, symlink_val, STRING_LENGTH - 1) ) < 0 )
     1015            if ((val = readlink(sourcepath, symlink_val, STRING_LENGTH - 1)) < 0)
    11601016                break;
    11611017            symlink_val[val] = '\0';
    1162             if (symlink (symlink_val, destpath) == 0)
    1163                 return (TRUE);
     1018            if (symlink(symlink_val, destpath) == 0)
     1019                return TRUE;
    11641020            break;
    11651021        case S_IFREG:
    1166             if ( ( fd = open (destpath, O_RDONLY | O_CREAT, new_mode & ~S_IFMT) ) < 0 )
     1022            if ((fd = open(destpath, O_RDONLY | O_CREAT, new_mode & ~S_IFMT)) < 0)
    11671023                break;
    1168             close (fd);
    1169             if (chmod (destpath, new_mode & ~S_IFMT) != 0)
     1024            close(fd);
     1025            if (chmod(destpath, new_mode & ~S_IFMT) != 0)
    11701026                break;
    11711027            goto do_chown;
     
    11731029        case S_IFCHR:
    11741030        case S_IFIFO:
    1175             if (mknod (destpath, new_mode, source_stat->st_rdev) != 0)
     1031            if (mknod(destpath, new_mode, source_stat->st_rdev) != 0)
    11761032                break;
    11771033            goto do_chown;
    11781034        case S_IFDIR:
    1179             if (mkdir (destpath, new_mode & ~S_IFMT) != 0)
     1035            if (mkdir(destpath, new_mode & ~S_IFMT) != 0)
    11801036                break;
    11811037do_chown:
    1182             if (chown (destpath, source_stat->st_uid, source_stat->st_gid) == 0)
    1183                 return (TRUE);
     1038            if (chown(destpath, source_stat->st_uid, source_stat->st_gid) == 0)
     1039                return TRUE;
    11841040        /*break;*/
    11851041    }
    1186     return (FALSE);
     1042    return FALSE;
    11871043}   /*  End Function copy_inode  */
    11881044
    1189 static void free_config (void)
     1045static void free_config(void)
    11901046/*  [SUMMARY] Free the configuration information.
    11911047    [RETURNS] Nothing.
     
    11951051    void *next;
    11961052
    1197     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1198 
    1199     for (c_entry = first_config; c_entry != NULL; c_entry = next)
    1200     {
     1053    for (c_entry = first_config; c_entry != NULL; c_entry = next) {
    12011054        unsigned int count;
    12021055
    12031056        next = c_entry->next;
    1204         regfree (&c_entry->preg);
    1205         if (c_entry->action.what == AC_EXECUTE)
    1206         {
    1207             for (count = 0; count < MAX_ARGS; ++count)
    1208             {
     1057        regfree(&c_entry->preg);
     1058        if (c_entry->action.what == AC_EXECUTE) {
     1059            for (count = 0; count < MAX_ARGS; ++count) {
    12091060                if (c_entry->u.execute.argv[count] == NULL)
    12101061                    break;
    1211                 free (c_entry->u.execute.argv[count]);
     1062                free(c_entry->u.execute.argv[count]);
    12121063            }
    12131064        }
    1214         free (c_entry);
     1065        free(c_entry);
    12151066    }
    12161067    first_config = NULL;
     
    12181069}   /*  End Function free_config  */
    12191070
    1220 static int get_uid_gid (int flag, const char *string)
     1071static int get_uid_gid(int flag, const char *string)
    12211072/*  [SUMMARY] Convert a string to a UID or GID value.
    12221073    <flag> "UID" or "GID".
     
    12271078    struct passwd *pw_ent;
    12281079    struct group *grp_ent;
    1229     static char *msg;
     1080    static const char *msg;
    12301081
    12311082    if (ENABLE_DEVFSD_VERBOSE)
    1232         msg="user";
    1233 
    1234     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1235 
    1236     if(ENABLE_DEBUG && flag != UID && flag != GID)
    1237         msg_logger_and_die(LOG_ERR,"%s: flag != UID && flag != GID", __FUNCTION__);
    1238 
    1239     if ( isdigit (string[0]) || ( (string[0] == '-') && isdigit (string[1]) ) )
    1240         return atoi (string);
    1241 
    1242     if ( flag == UID && ( pw_ent  = getpwnam (string) ) != NULL )
    1243         return (pw_ent->pw_uid);
    1244 
    1245     if ( flag == GID && ( grp_ent = getgrnam (string) ) != NULL )
    1246         return (grp_ent->gr_gid);
    1247     else if(ENABLE_DEVFSD_VERBOSE)
    1248         msg="group";
    1249 
    1250     if(ENABLE_DEVFSD_VERBOSE)
     1083        msg = "user";
     1084
     1085    if (isdigit(string[0]) ||((string[0] == '-') && isdigit(string[1])))
     1086        return atoi(string);
     1087
     1088    if (flag == UID && (pw_ent  = getpwnam(string)) != NULL)
     1089        return pw_ent->pw_uid;
     1090
     1091    if (flag == GID && (grp_ent = getgrnam(string)) != NULL)
     1092        return grp_ent->gr_gid;
     1093    else if (ENABLE_DEVFSD_VERBOSE)
     1094        msg = "group";
     1095
     1096    if (ENABLE_DEVFSD_VERBOSE)
    12511097        msg_logger(LOG_ERR,"unknown %s: %s, defaulting to %cid=0",  msg, string, msg[0]);
    1252     return (0);
     1098    return 0;
    12531099}/*  End Function get_uid_gid  */
    12541100
    1255 static mode_t get_mode (const char *string)
     1101static mode_t get_mode(const char *string)
    12561102/*  [SUMMARY] Convert a string to a mode value.
    12571103    <string> The string.
     
    12621108    int i;
    12631109
    1264     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1265 
    1266     if ( isdigit (string[0]) )
    1267         return strtoul (string, NULL, 8);
    1268     if (strlen (string) != 9)
     1110    if (isdigit(string[0]))
     1111        return strtoul(string, NULL, 8);
     1112    if (strlen(string) != 9)
    12691113        msg_logger_and_die(LOG_ERR, "bad mode: %s", string);
    12701114
    12711115    mode = 0;
    1272     i= S_IRUSR;
    1273     while(i>0)
    1274     {
    1275         if(string[0]=='r'||string[0]=='w'||string[0]=='x')
    1276             mode+=i;
    1277         i=i/2;
     1116    i = S_IRUSR;
     1117    while (i > 0) {
     1118        if (string[0] == 'r' || string[0] == 'w' || string[0] == 'x')
     1119            mode += i;
     1120        i = i / 2;
    12781121        string++;
    12791122    }
    1280     return (mode);
     1123    return mode;
    12811124}   /*  End Function get_mode  */
    12821125
    1283 static void signal_handler (int sig)
    1284 {
    1285     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1286 
     1126static void signal_handler(int sig)
     1127{
    12871128    caught_signal = TRUE;
    12881129    if (sig == SIGHUP)
    12891130        caught_sighup = TRUE;
    12901131
    1291     msg_logger(LOG_INFO, "Caught signal %d", sig);
     1132    info_logger(LOG_INFO, "Caught signal %d", sig);
    12921133}   /*  End Function signal_handler  */
    12931134
    1294 static const char *get_variable (const char *variable, void *info)
    1295 {
     1135static const char *get_variable(const char *variable, void *info)
     1136{
     1137    static char sbuf[sizeof(int)*3 + 2]; /* sign and NUL */
     1138
     1139    char hostname[STRING_LENGTH];
    12961140    struct get_variable_info *gv_info = info;
    1297     static char hostname[STRING_LENGTH], sbuf[STRING_LENGTH];
    1298     const char *field_names[] = { "hostname", "mntpt", "devpath", "devname",
    1299                                    "uid", "gid", "mode", hostname, mount_point,
    1300                                    gv_info->devpath, gv_info->devname, 0 };
     1141    const char *field_names[] = {
     1142            "hostname", "mntpt", "devpath", "devname",
     1143            "uid", "gid", "mode", hostname, mount_point,
     1144            gv_info->devpath, gv_info->devname, NULL
     1145    };
    13011146    int i;
    13021147
    1303     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1304 
    1305     if (gethostname (hostname, STRING_LENGTH - 1) != 0)
    1306         msg_logger_and_die(LOG_ERR, "gethostname: %m");
    1307 
     1148    if (gethostname(hostname, STRING_LENGTH - 1) != 0)
    13081149        /* Here on error we should do exit(RV_SYS_ERROR), instead we do exit(EXIT_FAILURE) */
    1309         hostname[STRING_LENGTH - 1] = '\0';
    1310 
    1311     /* compare_string_array returns i>=0  */
    1312     i=compare_string_array(field_names, variable);
    1313 
    1314     if ( i > 6 || i < 0 || (i > 1 && gv_info == NULL))
    1315             return (NULL);
    1316     if( i >= 0 && i <= 3)
    1317     {
    1318         debug_msg_logger(LOG_INFO, "%s: i=%d %s", __FUNCTION__, i ,field_names[i+7]);
    1319         return(field_names[i+7]);
    1320     }
    1321 
    1322     if(i == 4 )
    1323         sprintf (sbuf, "%u", gv_info->info->uid);
    1324     else if(i == 5)
    1325         sprintf (sbuf, "%u", gv_info->info->gid);
    1326     else if(i == 6)
    1327         sprintf (sbuf, "%o", gv_info->info->mode);
    1328 
    1329     debug_msg_logger(LOG_INFO, "%s: %s", __FUNCTION__, sbuf);
    1330 
    1331     return (sbuf);
     1150        error_logger_and_die(LOG_ERR, "gethostname");
     1151
     1152    hostname[STRING_LENGTH - 1] = '\0';
     1153
     1154    /* index_in_str_array returns i>=0  */
     1155    i = index_in_str_array(field_names, variable);
     1156
     1157    if (i > 6 || i < 0 || (i > 1 && gv_info == NULL))
     1158        return NULL;
     1159    if (i >= 0 && i <= 3)
     1160        return field_names[i + 7];
     1161
     1162    if (i == 4)
     1163        sprintf(sbuf, "%u", gv_info->info->uid);
     1164    else if (i == 5)
     1165        sprintf(sbuf, "%u", gv_info->info->gid);
     1166    else if (i == 6)
     1167        sprintf(sbuf, "%o", gv_info->info->mode);
     1168    return sbuf;
    13321169}   /*  End Function get_variable  */
    13331170
     
    13361173    struct devfsd_notify_struct info;
    13371174
    1338     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1339 
    1340     memset (&info, 0, sizeof info);
     1175    memset(&info, 0, sizeof info);
    13411176    info.type = DEVFSD_NOTIFY_REGISTERED;
    13421177    info.mode = statbuf.st_mode;
    1343     info.major = major (statbuf.st_rdev);
    1344     info.minor = minor (statbuf.st_rdev);
     1178    info.major = major(statbuf.st_rdev);
     1179    info.minor = minor(statbuf.st_rdev);
    13451180    info.uid = statbuf.st_uid;
    13461181    info.gid = statbuf.st_gid;
    1347     snprintf (info.devname, sizeof (info.devname), "%s", path + strlen (mount_point) + 1);
    1348     info.namelen = strlen (info.devname);
    1349     service_name (&info);
    1350     if ( S_ISDIR (statbuf.st_mode) )
    1351         dir_operation(SERVICE,path,0,NULL);
     1182    snprintf(info.devname, sizeof(info.devname), "%s", path + strlen(mount_point) + 1);
     1183    info.namelen = strlen(info.devname);
     1184    service_name(&info);
     1185    if (S_ISDIR(statbuf.st_mode))
     1186        dir_operation(SERVICE, path, 0, NULL);
    13521187}
    13531188
     
    13641199    DIR *dp;
    13651200    struct dirent *de;
    1366     char path[STRING_LENGTH];
    1367 
    1368     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1369 
    1370     if((dp = opendir( dir_name))==NULL)
    1371     {
    1372         debug_msg_logger(LOG_ERR, "opendir: %s: %m", dir_name);
     1201    char *path;
     1202
     1203    if ((dp = warn_opendir(dir_name)) == NULL)
    13731204        return;
    1374     }
    1375 
    1376     while ( (de = readdir (dp) ) != NULL )
    1377     {
    1378 
    1379         if(de->d_name && *de->d_name == '.' && (!de->d_name[1] || (de->d_name[1] == '.' && !de->d_name[2])))
     1205
     1206    while ((de = readdir(dp)) != NULL) {
     1207
     1208        if (de->d_name && DOT_OR_DOTDOT(de->d_name))
    13801209            continue;
    1381         snprintf (path, sizeof (path), "%s/%s", dir_name, de->d_name);
    1382         debug_msg_logger(LOG_ERR, "%s: %s", __FUNCTION__, path);
    1383 
    1384         if (lstat (path, &statbuf) != 0)
    1385         {
    1386             debug_msg_logger(LOG_ERR, "%s: %s: %m", __FUNCTION__, path);
    1387             continue;
     1210        path = concat_path_file(dir_name, de->d_name);
     1211        if (lstat(path, &statbuf) == 0) {
     1212            switch (type) {
     1213                case SERVICE:
     1214                    service(statbuf, path);
     1215                    break;
     1216                case RESTORE:
     1217                    restore(path, statbuf, var);
     1218                    break;
     1219                case READ_CONFIG:
     1220                    read_config_file(path, var, event_mask);
     1221                    break;
     1222            }
    13881223        }
    1389         switch(type)
    1390         {
    1391             case SERVICE:
    1392                 service(statbuf,path);
    1393                 break;
    1394             case RESTORE:
    1395                 restore(path, statbuf, var);
    1396                 break;
    1397             case READ_CONFIG:
    1398                 read_config_file (path, var, event_mask);
    1399                 break;
    1400         }
    1401     }
    1402     closedir (dp);
     1224        free(path);
     1225    }
     1226    closedir(dp);
    14031227}   /*  End Function do_scan_and_service  */
    14041228
    1405 static int mksymlink (const char *oldpath, const char *newpath)
     1229static int mksymlink(const char *oldpath, const char *newpath)
    14061230/*  [SUMMARY] Create a symlink, creating intervening directories as required.
    14071231    <oldpath> The string contained in the symlink.
     
    14101234*/
    14111235{
    1412     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1413 
    1414     if ( !make_dir_tree (newpath) )
    1415         return (-1);
    1416 
    1417     if (symlink (oldpath, newpath) != 0)
    1418     {
     1236    if (!make_dir_tree(newpath))
     1237        return -1;
     1238
     1239    if (symlink(oldpath, newpath) != 0) {
    14191240        if (errno != EEXIST)
    1420         {
    1421             debug_msg_logger(LOG_ERR, "%s: %s to %s: %m", __FUNCTION__, oldpath, newpath);
    1422             return (-1);
    1423         }
    1424     }
    1425     return (0);
     1241            return -1;
     1242    }
     1243    return 0;
    14261244}   /*  End Function mksymlink  */
    14271245
    14281246
    1429 static int make_dir_tree (const char *path)
     1247static int make_dir_tree(const char *path)
    14301248/*  [SUMMARY] Creating intervening directories for a path as required.
    1431     <path> The full pathname (including the leaf node).
     1249    <path> The full pathname(including the leaf node).
    14321250    [RETURNS] TRUE on success, else FALSE.
    14331251*/
    14341252{
    1435     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1436 
    1437     if (bb_make_directory( dirname((char *)path), -1, FILEUTILS_RECUR )==-1)
    1438     {
    1439         debug_msg_logger(LOG_ERR, "%s: %s: %m",__FUNCTION__, path);
    1440         return (FALSE);
    1441     }
    1442     return(TRUE);
     1253    if (bb_make_directory(dirname((char *)path), -1, FILEUTILS_RECUR) == -1)
     1254        return FALSE;
     1255    return TRUE;
    14431256} /*  End Function make_dir_tree  */
    14441257
     
    14661279    char temp[STRING_LENGTH];
    14671280
    1468     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1469 
    1470     if ( !st_expr_expand (temp, STRING_LENGTH, input, get_variable_func, info) )
    1471         return (FALSE);
    1472     expand_regexp (output, outsize, temp, devname, ex, numexp);
    1473     return (TRUE);
     1281    if (!st_expr_expand(temp, STRING_LENGTH, input, get_variable_func, info))
     1282        return FALSE;
     1283    expand_regexp(output, outsize, temp, devname, ex, numexp);
     1284    return TRUE;
    14741285}   /*  End Function expand_expression  */
    14751286
    1476 static void expand_regexp (char *output, size_t outsize, const char *input,
     1287static void expand_regexp(char *output, size_t outsize, const char *input,
    14771288               const char *devname,
    1478                const regmatch_t *ex, unsigned int numex )
     1289               const regmatch_t *ex, unsigned int numex)
    14791290/*  [SUMMARY] Expand all occurrences of the regular subexpressions \0 to \9.
    14801291    <output> The output expanded expression is written here.
     
    14951306    int c = -1;
    14961307
    1497     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1498 
    14991308    /*  Guarantee NULL termination by writing an explicit '\0' character into
    15001309    the very last byte  */
     
    15041313    and '\0' .. '\9' with subexpressions 0 .. 9, if they exist. Other \x
    15051314    codes are deleted  */
    1506     while ( (c != '\0') && (outsize != 0) )
    1507     {
     1315    while ((c != '\0') && (outsize != 0)) {
    15081316        c = *input;
    15091317        ++input;
    1510         if (c == '\\')
    1511         {
     1318        if (c == '\\') {
    15121319            c = *input;
    15131320            ++input;
    1514             if (c != '\\')
    1515             {
    1516                 if ((c >= '0') && (c <= last_exp))
    1517                 {
     1321            if (c != '\\') {
     1322                if ((c >= '0') && (c <= last_exp)) {
    15181323                    const regmatch_t *subexp = ex + (c - '0');
    15191324                    unsigned int sublen = subexp->rm_eo - subexp->rm_so;
     
    15221327                    if (sublen > outsize)
    15231328                        sublen = outsize;
    1524                     strncpy (output, devname + subexp->rm_so, sublen);
     1329                    strncpy(output, devname + subexp->rm_so, sublen);
    15251330                    output += sublen;
    15261331                    outsize -= sublen;
     
    15401345struct translate_struct
    15411346{
    1542     char *match;    /*  The string to match to (up to length)                */
    1543     char *format;   /*  Format of output, "%s" takes data past match string,
    1544             NULL is effectively "%s" (just more efficient)       */
     1347    const char *match;    /*  The string to match to(up to length)                */
     1348    const char *format;   /*  Format of output, "%s" takes data past match string,
     1349            NULL is effectively "%s"(just more efficient)       */
    15451350};
    15461351
     
    15781383};
    15791384
    1580 const char *get_old_name (const char *devname, unsigned int namelen,
     1385const char *get_old_name(const char *devname, unsigned int namelen,
    15811386              char *buffer, unsigned int major, unsigned int minor)
    15821387/*  [SUMMARY] Translate a kernel-supplied name into an old name.
     
    15901395{
    15911396    const char *compat_name = NULL;
    1592     char *ptr;
     1397    const char *ptr;
    15931398    struct translate_struct *trans;
    15941399    unsigned int i;
     
    16161421    };
    16171422
    1618     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1619 
    1620     for (trans = translate_table; trans->match != NULL; ++trans)
    1621     {
    1622          len = strlen (trans->match);
    1623 
    1624         if (strncmp (devname, trans->match, len) == 0)
    1625         {
     1423    for (trans = translate_table; trans->match != NULL; ++trans) {
     1424         len = strlen(trans->match);
     1425
     1426        if (strncmp(devname, trans->match, len) == 0) {
    16261427            if (trans->format == NULL)
    1627                 return (devname + len);
    1628             sprintf (buffer, trans->format, devname + len);
    1629             return (buffer);
     1428                return devname + len;
     1429            sprintf(buffer, trans->format, devname + len);
     1430            return buffer;
    16301431        }
    16311432    }
    16321433
    1633     ptr = (strrchr (devname, '/') + 1);
     1434    ptr = bb_basename(devname);
    16341435    i = scan_dev_name(devname, namelen, ptr);
    16351436
    1636     if( i > 0 && i < 13)
     1437    if (i > 0 && i < 13)
    16371438        compat_name = buffer;
    16381439    else
    16391440        return NULL;
    16401441
    1641     debug_msg_logger(LOG_INFO, "%s: scan_dev_name = %d", __FUNCTION__, i);
    1642 
    16431442    /* 1 == scsi/generic, 3 == scsi/cd, 10 == sbp/ */
    1644     if( i == 1 || i == 3 || i == 10 )
    1645         sprintf (buffer, fmt[i], minor);
     1443    if (i == 1 || i == 3 || i == 10)
     1444        sprintf(buffer, fmt[i], minor);
    16461445
    16471446    /* 2 ==scsi/disc, 4 == scsi/part */
    1648     if( i == 2 || i == 4)
    1649         compat_name = write_old_sd_name (buffer, major, minor,((i == 2)?"":(ptr + 4)));
     1447    if (i == 2 || i == 4)
     1448        compat_name = write_old_sd_name(buffer, major, minor,((i == 2) ? "" : (ptr + 4)));
    16501449
    16511450    /* 5 == scsi/mt */
    1652     if( i == 5)
    1653     {
     1451    if (i == 5) {
    16541452        mode = ptr[2];
    16551453        if (mode == 'n')
    16561454            mode = '\0';
    1657         sprintf (buffer, fmt[i], minor & 0x1f, mode);
     1455        sprintf(buffer, fmt[i], minor & 0x1f, mode);
    16581456        if (devname[namelen - 1] != 'n')
    16591457            ++compat_name;
    16601458    }
    16611459    /* 6 == ide/host/disc, 7 == ide/host/cd, 8 == ide/host/part */
    1662     if( i == 6 || i == 7 || i == 8 )
     1460    if (i == 6 || i == 7 || i == 8)
    16631461        /* last arg should be ignored for i == 6 or i== 7 */
    1664         sprintf (buffer, fmt[i] , get_old_ide_name (major, minor), ptr + 4);
     1462        sprintf(buffer, fmt[i] , get_old_ide_name(major, minor), ptr + 4);
    16651463
    16661464    /* 9 ==  ide/host/mt */
    1667     if( i == 9 )
    1668         sprintf (buffer, fmt[i], ptr + 2, minor & 0x7f);
     1465    if (i == 9)
     1466        sprintf(buffer, fmt[i], ptr + 2, minor & 0x7f);
    16691467
    16701468    /*  11 == vcc/ */
    1671     if( i == 11 )
    1672     {
    1673         sprintf (buffer, fmt[i], devname + 4);
     1469    if (i == 11) {
     1470        sprintf(buffer, fmt[i], devname + 4);
    16741471        if (buffer[3] == '0')
    16751472            buffer[3] = '\0';
    16761473    }
    16771474    /* 12 ==  pty/ */
    1678     if( i == 12 )
    1679     {
     1475    if (i == 12) {
    16801476        pty1 = "pqrstuvwxyzabcde";
    16811477        pty2 = "0123456789abcdef";
    1682         indexx = atoi (devname + 5);
    1683         sprintf (buffer, fmt[i], (devname[4] == 'm') ? 'p' : 't', pty1[indexx >> 4], pty2[indexx & 0x0f]);
    1684     }
    1685 
    1686     if(ENABLE_DEBUG && compat_name!=NULL)
    1687         msg_logger(LOG_INFO, "%s: compat_name  %s", __FUNCTION__, compat_name);
    1688 
    1689     return (compat_name);
     1478        indexx = atoi(devname + 5);
     1479        sprintf(buffer, fmt[i], (devname[4] == 'm') ? 'p' : 't', pty1[indexx >> 4], pty2[indexx & 0x0f]);
     1480    }
     1481    return compat_name;
    16901482}   /*  End Function get_old_name  */
    16911483
    1692 static char get_old_ide_name (unsigned int major, unsigned int minor)
     1484static char get_old_ide_name(unsigned int major, unsigned int minor)
    16931485/*  [SUMMARY] Get the old IDE name for a device.
    16941486    <major> The major number for the device.
     
    16971489*/
    16981490{
    1699     char letter='y';    /* 121 */
    1700     char c='a';     /*  97 */
    1701     int i=IDE0_MAJOR;
    1702 
    1703     debug_msg_logger(LOG_INFO, __FUNCTION__);
     1491    char letter = 'y';  /* 121 */
     1492    char c = 'a';       /*  97 */
     1493    int i = IDE0_MAJOR;
    17041494
    17051495    /* I hope it works like the previous code as it saves a few bytes. Tito ;P */
    17061496    do {
    1707         if( i==IDE0_MAJOR || i==IDE1_MAJOR || i==IDE2_MAJOR ||
    1708             i==IDE3_MAJOR || i==IDE4_MAJOR || i==IDE5_MAJOR ||
    1709             i==IDE6_MAJOR || i==IDE7_MAJOR || i==IDE8_MAJOR ||
    1710             i==IDE9_MAJOR )
    1711         {
    1712             if((unsigned int)i==major)
    1713             {
    1714                 letter=c;
     1497        if (i == IDE0_MAJOR || i == IDE1_MAJOR || i == IDE2_MAJOR
     1498         || i == IDE3_MAJOR || i == IDE4_MAJOR || i == IDE5_MAJOR
     1499         || i == IDE6_MAJOR || i == IDE7_MAJOR || i == IDE8_MAJOR
     1500         || i == IDE9_MAJOR
     1501        ) {
     1502            if ((unsigned int)i == major) {
     1503                letter = c;
    17151504                break;
    17161505            }
    1717             c+=2;
     1506            c += 2;
    17181507        }
    17191508        i++;
    1720     } while(i<=IDE9_MAJOR);
     1509    } while (i <= IDE9_MAJOR);
    17211510
    17221511    if (minor > 63)
    17231512        ++letter;
    1724     return (letter);
     1513    return letter;
    17251514}   /*  End Function get_old_ide_name  */
    17261515
    1727 static char *write_old_sd_name (char *buffer,
     1516static char *write_old_sd_name(char *buffer,
    17281517                unsigned int major, unsigned int minor,
    1729                 char *part)
     1518                const char *part)
    17301519/*  [SUMMARY] Write the old SCSI disc name to a buffer.
    17311520    <buffer> The buffer to write to.
     
    17381527    unsigned int disc_index;
    17391528
    1740     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1741 
    1742     if (major == 8)
    1743     {
    1744         sprintf (buffer, "sd%c%s", 'a' + (minor >> 4), part);
    1745         return (buffer);
    1746     }
    1747     if ( (major > 64) && (major < 72) )
    1748     {
    1749         disc_index = ( (major - 64) << 4 ) + (minor >> 4);
     1529    if (major == 8) {
     1530        sprintf(buffer, "sd%c%s", 'a' + (minor >> 4), part);
     1531        return buffer;
     1532    }
     1533    if ((major > 64) && (major < 72)) {
     1534        disc_index = ((major - 64) << 4) +(minor >> 4);
    17501535        if (disc_index < 26)
    1751             sprintf (buffer, "sd%c%s", 'a' + disc_index, part);
     1536            sprintf(buffer, "sd%c%s", 'a' + disc_index, part);
    17521537        else
    1753             sprintf (buffer, "sd%c%c%s", 'a' + (disc_index / 26) - 1, 'a' + disc_index % 26,part);
    1754         return (buffer);
    1755     }
    1756     return (NULL);
     1538            sprintf(buffer, "sd%c%c%s", 'a' +(disc_index / 26) - 1, 'a' + disc_index % 26, part);
     1539        return buffer;
     1540    }
     1541    return NULL;
    17571542}   /*  End Function write_old_sd_name  */
    17581543
     
    17621547/*EXPERIMENTAL_FUNCTION*/
    17631548
    1764 int st_expr_expand (char *output, unsigned int length, const char *input,
    1765              const char *(*get_variable_func) (const char *variable,
     1549int st_expr_expand(char *output, unsigned int length, const char *input,
     1550             const char *(*get_variable_func)(const char *variable,
    17661551                          void *info),
    17671552             void *info)
     
    17851570    char buffer[BUFFER_SIZE], tmp[STRING_LENGTH];
    17861571
    1787     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1788 
    17891572    if (length > BUFFER_SIZE)
    17901573        length = BUFFER_SIZE;
    1791     for (; TRUE; ++input)
    1792     {
    1793         switch (ch = *input)
    1794         {
     1574    for (; TRUE; ++input) {
     1575        switch (ch = *input) {
    17951576            case '$':
    17961577                /*  Variable expansion  */
    1797                 input = expand_variable (buffer, length, &out_pos, ++input, get_variable_func, info);
     1578                input = expand_variable(buffer, length, &out_pos, ++input, get_variable_func, info);
    17981579                if (input == NULL)
    1799                     return (FALSE);
     1580                    return FALSE;
    18001581                break;
    18011582            case '~':
    18021583                /*  Home directory expansion  */
    18031584                ch = input[1];
    1804                 if ( isspace (ch) || (ch == '/') || (ch == '\0') )
    1805                 {
     1585                if (isspace(ch) ||(ch == '/') ||(ch == '\0')) {
    18061586                    /* User's own home directory: leave separator for next time */
    1807                     if ( ( env = getenv ("HOME") ) == NULL )
    1808                     {
    1809                         msg_logger(LOG_INFO, bb_msg_variable_not_found, "HOME");
    1810                         return (FALSE);
     1587                    if ((env = getenv("HOME")) == NULL) {
     1588                        info_logger(LOG_INFO, bb_msg_variable_not_found, "HOME");
     1589                        return FALSE;
    18111590                    }
    1812                     len = strlen (env);
     1591                    len = strlen(env);
    18131592                    if (len + out_pos >= length)
    18141593                        goto st_expr_expand_out;
    1815                     memcpy (buffer + out_pos, env, len + 1);
     1594                    memcpy(buffer + out_pos, env, len + 1);
    18161595                    out_pos += len;
    18171596                    continue;
    18181597                }
    18191598                /*  Someone else's home directory  */
    1820                 for (ptr = ++input; !isspace (ch) && (ch != '/') && (ch != '\0'); ch = *++ptr)
    1821                     /* VOID */ ;
     1599                for (ptr = ++input; !isspace(ch) && (ch != '/') && (ch != '\0'); ch = *++ptr)
     1600                    /* VOID */;
    18221601                len = ptr - input;
    18231602                if (len >= sizeof tmp)
    18241603                    goto st_expr_expand_out;
    1825                 safe_memcpy (tmp, input, len);
     1604                safe_memcpy(tmp, input, len);
    18261605                input = ptr - 1;
    1827                 if ( ( pwent = getpwnam (tmp) ) == NULL )
    1828                 {
    1829                     msg_logger(LOG_INFO, "no pwent for: %s", tmp);
    1830                     return (FALSE);
     1606                if ((pwent = getpwnam(tmp)) == NULL) {
     1607                    info_logger(LOG_INFO, "no pwent for: %s", tmp);
     1608                    return FALSE;
    18311609                }
    1832                 len = strlen (pwent->pw_dir);
     1610                len = strlen(pwent->pw_dir);
    18331611                if (len + out_pos >= length)
    18341612                    goto st_expr_expand_out;
    1835                 memcpy (buffer + out_pos, pwent->pw_dir, len + 1);
     1613                memcpy(buffer + out_pos, pwent->pw_dir, len + 1);
    18361614                out_pos += len;
    18371615                break;
     
    18421620                    goto st_expr_expand_out;
    18431621                buffer[out_pos++] = ch;
    1844                 if (ch == '\0')
    1845                 {
    1846                     memcpy (output, buffer, out_pos);
    1847                     return (TRUE);
     1622                if (ch == '\0') {
     1623                    memcpy(output, buffer, out_pos);
     1624                    return TRUE;
    18481625                }
    18491626                break;
     
    18511628        }
    18521629    }
    1853     return (FALSE);
     1630    return FALSE;
    18541631st_expr_expand_out:
    1855     msg_logger(LOG_INFO, bb_msg_small_buffer);
    1856     return (FALSE);
     1632    info_logger(LOG_INFO, bb_msg_small_buffer);
     1633    return FALSE;
    18571634}   /*  End Function st_expr_expand  */
    18581635
     
    18601637/*  Private functions follow  */
    18611638
    1862 static const char *expand_variable (char *buffer, unsigned int length,
     1639static const char *expand_variable(char *buffer, unsigned int length,
    18631640                    unsigned int *out_pos, const char *input,
    1864                     const char *(*func) (const char *variable,
     1641                    const char *(*func)(const char *variable,
    18651642                             void *info),
    18661643                    void *info)
     
    18841661    char tmp[STRING_LENGTH];
    18851662
    1886     debug_msg_logger(LOG_INFO, __FUNCTION__);
    1887 
    18881663    ch = input[0];
    1889     if (ch == '$')
    1890     {
     1664    if (ch == '$') {
    18911665        /*  Special case for "$$": PID  */
    1892         sprintf ( tmp, "%d", (int) getpid () );
    1893         len = strlen (tmp);
     1666        sprintf(tmp, "%d",(int) getpid());
     1667        len = strlen(tmp);
    18941668        if (len + *out_pos >= length)
    18951669            goto expand_variable_out;
    18961670
    1897         memcpy (buffer + *out_pos, tmp, len + 1);
     1671        memcpy(buffer + *out_pos, tmp, len + 1);
    18981672        out_pos += len;
    1899         return (input);
     1673        return input;
    19001674    }
    19011675    /*  Ordinary variable expansion, possibly in braces  */
    1902     if (ch != '{')
    1903     {
     1676    if (ch != '{') {
    19041677        /*  Simple variable expansion  */
    1905         for (ptr = input; isalnum (ch) || (ch == '_') || (ch == ':');ch = *++ptr)
    1906             /* VOID */ ;
     1678        for (ptr = input; isalnum(ch) || (ch == '_') || (ch == ':'); ch = *++ptr)
     1679            /* VOID */;
    19071680        len = ptr - input;
    19081681        if ((size_t)len >= sizeof tmp)
    19091682            goto expand_variable_out;
    19101683
    1911         safe_memcpy (tmp, input, len);
     1684        safe_memcpy(tmp, input, len);
    19121685        input = ptr - 1;
    1913         if ( ( env = get_variable_v2 (tmp, func, info) ) == NULL )
    1914         {
    1915             msg_logger(LOG_INFO, bb_msg_variable_not_found, tmp);
    1916             return (NULL);
     1686        if ((env = get_variable_v2(tmp, func, info)) == NULL) {
     1687            info_logger(LOG_INFO, bb_msg_variable_not_found, tmp);
     1688            return NULL;
    19171689        }
    1918         len = strlen (env);
     1690        len = strlen(env);
    19191691        if (len + *out_pos >= length)
    19201692            goto expand_variable_out;
    19211693
    1922         memcpy (buffer + *out_pos, env, len + 1);
     1694        memcpy(buffer + *out_pos, env, len + 1);
    19231695        *out_pos += len;
    1924         return (input);
     1696        return input;
    19251697    }
    19261698    /*  Variable in braces: check for ':' tricks  */
    19271699    ch = *++input;
    1928     for (ptr = input; isalnum (ch) || (ch == '_'); ch = *++ptr)
     1700    for (ptr = input; isalnum(ch) || (ch == '_'); ch = *++ptr)
    19291701        /* VOID */;
    1930     if (ch == '}')
    1931     {
     1702    if (ch == '}') {
    19321703        /*  Must be simple variable expansion with "${var}"  */
    19331704        len = ptr - input;
     
    19351706            goto expand_variable_out;
    19361707
    1937         safe_memcpy (tmp, input, len);
    1938         ptr = expand_variable (buffer, length, out_pos, tmp, func, info );
     1708        safe_memcpy(tmp, input, len);
     1709        ptr = expand_variable(buffer, length, out_pos, tmp, func, info);
    19391710        if (ptr == NULL)
    1940             return (NULL);
    1941         return (input + len);
    1942     }
    1943     if (ch != ':' || ptr[1] != '-' )
    1944     {
    1945         msg_logger(LOG_INFO, "illegal char in var name");
    1946         return (NULL);
     1711            return NULL;
     1712        return input + len;
     1713    }
     1714    if (ch != ':' || ptr[1] != '-') {
     1715        info_logger(LOG_INFO, "illegal char in var name");
     1716        return NULL;
    19471717    }
    19481718    /*  It's that handy "${var:-word}" expression. Check if var is defined  */
     
    19511721        goto expand_variable_out;
    19521722
    1953     safe_memcpy (tmp, input, len);
     1723    safe_memcpy(tmp, input, len);
    19541724    /*  Move input pointer to ':'  */
    19551725    input = ptr;
     
    19571727    ptr += 2;
    19581728    ch = ptr[0];
    1959     for (open_braces = 1; open_braces > 0; ch = *++ptr)
    1960     {
    1961         switch (ch)
    1962         {
     1729    for (open_braces = 1; open_braces > 0; ch = *++ptr) {
     1730        switch (ch) {
    19631731            case '{':
    19641732                ++open_braces;
     
    19681736                break;
    19691737            case '\0':
    1970                 msg_logger(LOG_INFO,"\"}\" not found in: %s", input);
    1971                 return (NULL);
     1738                info_logger(LOG_INFO,"\"}\" not found in: %s", input);
     1739                return NULL;
    19721740            default:
    19731741                break;
     
    19761744    --ptr;
    19771745    /*  At this point ptr should point to closing brace of "${var:-word}"  */
    1978     if ( ( env = get_variable_v2 (tmp, func, info) ) != NULL )
    1979     {
     1746    if ((env = get_variable_v2(tmp, func, info)) != NULL) {
    19801747        /*  Found environment variable, so skip the input to the closing brace
    19811748            and return the variable  */
    19821749        input = ptr;
    1983         len = strlen (env);
     1750        len = strlen(env);
    19841751        if (len + *out_pos >= length)
    19851752            goto expand_variable_out;
    19861753
    1987         memcpy (buffer + *out_pos, env, len + 1);
     1754        memcpy(buffer + *out_pos, env, len + 1);
    19881755        *out_pos += len;
    1989         return (input);
     1756        return input;
    19901757    }
    19911758    /*  Environment variable was not found, so process word. Advance input
     
    19961763        goto expand_variable_out;
    19971764
    1998     safe_memcpy (tmp, input, len);
     1765    safe_memcpy(tmp, input, len);
    19991766    input = ptr;
    2000     if ( !st_expr_expand (tmp, STRING_LENGTH, tmp, func, info ) )
    2001         return (NULL);
    2002     len = strlen (tmp);
     1767    if (!st_expr_expand(tmp, STRING_LENGTH, tmp, func, info))
     1768        return NULL;
     1769    len = strlen(tmp);
    20031770    if (len + *out_pos >= length)
    20041771        goto expand_variable_out;
    20051772
    2006     memcpy (buffer + *out_pos, tmp, len + 1);
     1773    memcpy(buffer + *out_pos, tmp, len + 1);
    20071774    *out_pos += len;
    2008     return (input);
     1775    return input;
    20091776expand_variable_out:
    2010     msg_logger(LOG_INFO, bb_msg_small_buffer);
    2011     return (NULL);
     1777    info_logger(LOG_INFO, bb_msg_small_buffer);
     1778    return NULL;
    20121779}   /*  End Function expand_variable  */
    20131780
    20141781
    2015 static const char *get_variable_v2 (const char *variable,
    2016                   const char *(*func) (const char *variable, void *info),
     1782static const char *get_variable_v2(const char *variable,
     1783                  const char *(*func)(const char *variable, void *info),
    20171784                 void *info)
    20181785/*  [SUMMARY] Get a variable from the environment or .
     
    20261793    const char *value;
    20271794
    2028     debug_msg_logger(LOG_INFO, __FUNCTION__);
    2029 
    2030     if (func != NULL)
    2031     {
    2032         value = (*func) (variable, info);
     1795    if (func != NULL) {
     1796        value = (*func)(variable, info);
    20331797        if (value != NULL)
    2034             return (value);
    2035     }
    2036     return getenv (variable);
     1798            return value;
     1799    }
     1800    return getenv(variable);
    20371801}   /*  End Function get_variable  */
    20381802
  • branches/stable/mindi-busybox/miscutils/eject.c

    r821 r1770  
    1414 */
    1515
    16 #include "busybox.h"
    17 #include <fcntl.h>
    18 #include <sys/ioctl.h>
    19 #include <unistd.h>
    20 #include <mntent.h>
     16#include "libbb.h"
    2117
    2218/* various defines swiped from linux/cdrom.h */
    2319#define CDROMCLOSETRAY            0x5319  /* pendant of CDROMEJECT  */
    2420#define CDROMEJECT                0x5309  /* Ejects the cdrom media */
    25 #define DEFAULT_CDROM             "/dev/cdrom"
     21#define CDROM_DRIVE_STATUS        0x5326  /* Get tray position, etc. */
     22/* drive status possibilities returned by CDROM_DRIVE_STATUS ioctl */
     23#define CDS_TRAY_OPEN        2
    2624
     25#define FLAG_CLOSE  1
     26#define FLAG_SMART  2
     27
     28int eject_main(int argc, char **argv);
    2729int eject_main(int argc, char **argv)
    2830{
    2931    unsigned long flags;
    30     char *device;
    31     struct mntent *m;
     32    const char *device;
     33    int dev, cmd;
    3234
    33     flags = bb_getopt_ulflags(argc, argv, "t");
    34     device = argv[optind] ? : DEFAULT_CDROM;
     35    opt_complementary = "?1:t--T:T--t";
     36    flags = getopt32(argv, "tT");
     37    device = argv[optind] ? : "/dev/cdrom";
    3538
    36     if ((m = find_mount_point(device, bb_path_mtab_file))) {
    37         if (umount(m->mnt_dir)) {
    38             bb_error_msg_and_die("Can't umount");
    39         } else if (ENABLE_FEATURE_MTAB_SUPPORT) {
    40             erase_mtab(m->mnt_fsname);
    41         }
    42     }
    43     if (ioctl(bb_xopen(device, (O_RDONLY | O_NONBLOCK)),
    44                 (flags ? CDROMCLOSETRAY : CDROMEJECT))) {
    45         bb_perror_msg_and_die("%s", device);
    46     }
    47     return (EXIT_SUCCESS);
     39    // We used to do "umount <device>" here, but it was buggy
     40    // if something was mounted OVER cdrom and
     41    // if cdrom is mounted many times.
     42    //
     43    // This works equally well (or better):
     44    // #!/bin/sh
     45    // umount /dev/cdrom
     46    // eject
     47
     48    dev = xopen(device, O_RDONLY|O_NONBLOCK);
     49    cmd = CDROMEJECT;
     50    if (flags & FLAG_CLOSE
     51     || (flags & FLAG_SMART && ioctl(dev, CDROM_DRIVE_STATUS) == CDS_TRAY_OPEN))
     52        cmd = CDROMCLOSETRAY;
     53
     54    ioctl_or_perror_and_die(dev, cmd, NULL, "%s", device);
     55
     56    if (ENABLE_FEATURE_CLEAN_UP)
     57        close(dev);
     58
     59    return EXIT_SUCCESS;
    4860}
  • branches/stable/mindi-busybox/miscutils/hdparm.c

    r902 r1770  
    1313 */
    1414
    15 #include "busybox.h"
    16 #include <string.h>
    17 #include <fcntl.h>
    18 #include <errno.h>
    19 #include <ctype.h>
    20 #include <sys/ioctl.h>
    21 #include <sys/sysmacros.h>
    22 #include <sys/times.h>
    23 #include <sys/mman.h>
    24 #include <linux/types.h>
     15#include "libbb.h"
    2516#include <linux/hdreg.h>
    26 
    27 #if BB_BIG_ENDIAN && !defined(__USE_XOPEN)
    28 # define __USE_XOPEN
    29 #endif
    30 #include <unistd.h>
    3117
    3218/* device types */
     
    5440#define START_MODEL     27  /* ASCII model number */
    5541#define LENGTH_MODEL        20  /* 20 words (40 bytes or characters) */
    56 #define SECTOR_XFER_MAX         47  /* r/w multiple: max sectors xfered */
     42#define SECTOR_XFER_MAX     47  /* r/w multiple: max sectors xfered */
    5743#define DWORD_IO        48  /* can do double-word IO (ATA-1 only) */
    5844#define CAPAB_0         49  /* capabilities */
     
    6349#define LCYLS_CUR       54  /* current logical cylinders */
    6450#define LHEADS_CUR      55  /* current logical heads */
    65 #define LSECTS_CUR          56  /* current logical sectors/track */
     51#define LSECTS_CUR      56  /* current logical sectors/track */
    6652#define CAPACITY_LSB        57  /* current capacity in sectors */
    6753#define CAPACITY_MSB        58
     
    142128#define CDROM 0x0005
    143129
    144 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
    145 static const char * const pkt_str[] = {
     130#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
     131static const char *const pkt_str[] = {
    146132    "Direct-access device",         /* word 0, bits 12-8 = 00 */
    147133    "Sequential-access device",     /* word 0, bits 12-8 = 01 */
     
    178164};
    179165
    180 static const char * const ata1_cfg_str[] = {            /* word 0 in ATA-1 mode */
     166static const char *const ata1_cfg_str[] = {         /* word 0 in ATA-1 mode */
    181167    "Reserved",             /* bit 0 */
    182168    "hard sectored",            /* bit 1 */
     
    215201
    216202/* word 49: capabilities 0 */
    217 #define STD_STBY        0x2000  /* 1=standard values supported (ATA);
    218                        0=vendor specific values */
     203#define STD_STBY        0x2000  /* 1=standard values supported (ATA); 0=vendor specific values */
    219204#define IORDY_SUP       0x0800  /* 1=support; 0=may be supported */
    220205#define IORDY_OFF       0x0400  /* 1=may be disabled */
     
    254239/* word 81: minor version number */
    255240#define MINOR_MAX       0x22
    256 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
    257 static const char *minor_str[MINOR_MAX+2] = {           /* word 81 value: */
    258     "Unspecified",                  /* 0x0000   */
    259     "ATA-1 X3T9.2 781D prior to rev.4", /* 0x0001   */
    260     "ATA-1 published, ANSI X3.221-1994",        /* 0x0002   */
    261     "ATA-1 X3T9.2 781D rev.4",          /* 0x0003   */
    262     "ATA-2 published, ANSI X3.279-1996",        /* 0x0004   */
    263     "ATA-2 X3T10 948D prior to rev.2k", /* 0x0005   */
    264     "ATA-3 X3T10 2008D rev.1",          /* 0x0006   */
    265     "ATA-2 X3T10 948D rev.2k",          /* 0x0007   */
    266     "ATA-3 X3T10 2008D rev.0",          /* 0x0008   */
    267     "ATA-2 X3T10 948D rev.3",           /* 0x0009   */
    268     "ATA-3 published, ANSI X3.298-199x",        /* 0x000a   */
    269     "ATA-3 X3T10 2008D rev.6",          /* 0x000b   */
    270     "ATA-3 X3T13 2008D rev.7 and 7a",       /* 0x000c   */
    271     "ATA/ATAPI-4 X3T13 1153D rev.6",        /* 0x000d   */
    272     "ATA/ATAPI-4 T13 1153D rev.13",     /* 0x000e   */
    273     "ATA/ATAPI-4 X3T13 1153D rev.7",        /* 0x000f   */
    274     "ATA/ATAPI-4 T13 1153D rev.18",     /* 0x0010   */
    275     "ATA/ATAPI-4 T13 1153D rev.15",     /* 0x0011   */
    276     "ATA/ATAPI-4 published, ANSI INCITS 317-1998",  /* 0x0012   */
    277     "ATA/ATAPI-5 T13 1321D rev.3",
    278     "ATA/ATAPI-4 T13 1153D rev.14",     /* 0x0014   */
    279     "ATA/ATAPI-5 T13 1321D rev.1",      /* 0x0015   */
    280     "ATA/ATAPI-5 published, ANSI INCITS 340-2000",  /* 0x0016   */
    281     "ATA/ATAPI-4 T13 1153D rev.17",     /* 0x0017   */
    282     "ATA/ATAPI-6 T13 1410D rev.0",      /* 0x0018   */
    283     "ATA/ATAPI-6 T13 1410D rev.3a",     /* 0x0019   */
    284     "ATA/ATAPI-7 T13 1532D rev.1",      /* 0x001a   */
    285     "ATA/ATAPI-6 T13 1410D rev.2",      /* 0x001b   */
    286     "ATA/ATAPI-6 T13 1410D rev.1",      /* 0x001c   */
    287     "ATA/ATAPI-7 published, ANSI INCITS 397-2005",  /* 0x001d   */
    288     "ATA/ATAPI-7 T13 1532D rev.0",      /* 0x001e   */
    289     "Reserved"                  /* 0x001f   */
    290     "Reserved"                  /* 0x0020   */
    291     "ATA/ATAPI-7 T13 1532D rev.4a",     /* 0x0021   */
    292     "ATA/ATAPI-6 published, ANSI INCITS 361-2002",  /* 0x0022   */
    293     "Reserved"                  /* 0x0023-0xfffe*/
     241#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
     242static const char *const minor_str[MINOR_MAX + 2] = {
     243    /* word 81 value: */
     244    "Unspecified",                                  /* 0x0000 */
     245    "ATA-1 X3T9.2 781D prior to rev.4",             /* 0x0001 */
     246    "ATA-1 published, ANSI X3.221-1994",            /* 0x0002 */
     247    "ATA-1 X3T9.2 781D rev.4",                      /* 0x0003 */
     248    "ATA-2 published, ANSI X3.279-1996",            /* 0x0004 */
     249    "ATA-2 X3T10 948D prior to rev.2k",             /* 0x0005 */
     250    "ATA-3 X3T10 2008D rev.1",                      /* 0x0006 */
     251    "ATA-2 X3T10 948D rev.2k",                      /* 0x0007 */
     252    "ATA-3 X3T10 2008D rev.0",                      /* 0x0008 */
     253    "ATA-2 X3T10 948D rev.3",                       /* 0x0009 */
     254    "ATA-3 published, ANSI X3.298-199x",            /* 0x000a */
     255    "ATA-3 X3T10 2008D rev.6",                      /* 0x000b */
     256    "ATA-3 X3T13 2008D rev.7 and 7a",               /* 0x000c */
     257    "ATA/ATAPI-4 X3T13 1153D rev.6",                /* 0x000d */
     258    "ATA/ATAPI-4 T13 1153D rev.13",                 /* 0x000e */
     259    "ATA/ATAPI-4 X3T13 1153D rev.7",                /* 0x000f */
     260    "ATA/ATAPI-4 T13 1153D rev.18",                 /* 0x0010 */
     261    "ATA/ATAPI-4 T13 1153D rev.15",                 /* 0x0011 */
     262    "ATA/ATAPI-4 published, ANSI INCITS 317-1998",  /* 0x0012 */
     263    "ATA/ATAPI-5 T13 1321D rev.3",                  /* 0x0013 */
     264    "ATA/ATAPI-4 T13 1153D rev.14",                 /* 0x0014 */
     265    "ATA/ATAPI-5 T13 1321D rev.1",                  /* 0x0015 */
     266    "ATA/ATAPI-5 published, ANSI INCITS 340-2000",  /* 0x0016 */
     267    "ATA/ATAPI-4 T13 1153D rev.17",                 /* 0x0017 */
     268    "ATA/ATAPI-6 T13 1410D rev.0",                  /* 0x0018 */
     269    "ATA/ATAPI-6 T13 1410D rev.3a",                 /* 0x0019 */
     270    "ATA/ATAPI-7 T13 1532D rev.1",                  /* 0x001a */
     271    "ATA/ATAPI-6 T13 1410D rev.2",                  /* 0x001b */
     272    "ATA/ATAPI-6 T13 1410D rev.1",                  /* 0x001c */
     273    "ATA/ATAPI-7 published, ANSI INCITS 397-2005",  /* 0x001d */
     274    "ATA/ATAPI-7 T13 1532D rev.0",                  /* 0x001e */
     275    "Reserved"                                      /* 0x001f */
     276    "Reserved"                                      /* 0x0020 */
     277    "ATA/ATAPI-7 T13 1532D rev.4a",                 /* 0x0021 */
     278    "ATA/ATAPI-6 published, ANSI INCITS 361-2002",  /* 0x0022 */
     279    "Reserved"                                      /* 0x0023-0xfffe */
    294280};
    295281#endif
    296 static const char actual_ver[MINOR_MAX+2] = {
    297             /* word 81 value: */
    298     0,      /* 0x0000   WARNING:    */
    299     1,      /* 0x0001   WARNING:    */
    300     1,      /* 0x0002   WARNING:    */
    301     1,      /* 0x0003   WARNING:    */
    302     2,      /* 0x0004   WARNING:   This array       */
    303     2,      /* 0x0005   WARNING:   corresponds      */
    304     3,      /* 0x0006   WARNING:   *exactly*        */
    305     2,      /* 0x0007   WARNING:   to the ATA/      */
    306     3,      /* 0x0008   WARNING:   ATAPI version    */
    307     2,      /* 0x0009   WARNING:   listed in        */
    308     3,      /* 0x000a   WARNING:   the          */
    309     3,      /* 0x000b   WARNING:   minor_str        */
    310     3,      /* 0x000c   WARNING:   array        */
    311     4,      /* 0x000d   WARNING:   above.       */
    312     4,      /* 0x000e   WARNING:            */
    313     4,      /* 0x000f   WARNING:   if you change    */
    314     4,      /* 0x0010   WARNING:   that one,        */
    315     4,      /* 0x0011   WARNING:   change this one  */
    316     4,      /* 0x0012   WARNING:   too!!!       */
    317     5,      /* 0x0013   WARNING:    */
    318     4,      /* 0x0014   WARNING:    */
    319     5,      /* 0x0015   WARNING:    */
    320     5,      /* 0x0016   WARNING:    */
    321     4,      /* 0x0017   WARNING:    */
    322     6,      /* 0x0018   WARNING:    */
    323     6,      /* 0x0019   WARNING:    */
    324     7,      /* 0x001a   WARNING:    */
    325     6,      /* 0x001b   WARNING:    */
    326     6,      /* 0x001c   WARNING:    */
    327     7,      /* 0x001d   WARNING:    */
    328     7,      /* 0x001e   WARNING:    */
    329     0,      /* 0x001f   WARNING:    */
    330     0,      /* 0x0020   WARNING:    */
    331     7,      /* 0x0021   WARNING:    */
    332     6,      /* 0x0022   WARNING:    */
    333     0       /* 0x0023-0xfffe        */
     282static const char actual_ver[MINOR_MAX + 2] ALIGN1 = {
     283       /* word 81 value: */
     284    0, /* 0x0000 WARNING: actual_ver[] array */
     285    1, /* 0x0001 WARNING: corresponds        */
     286    1, /* 0x0002 WARNING: *exactly*          */
     287    1, /* 0x0003 WARNING: to the ATA/        */
     288    2, /* 0x0004 WARNING: ATAPI version      */
     289    2, /* 0x0005 WARNING: listed in          */
     290    3, /* 0x0006 WARNING: the                */
     291    2, /* 0x0007 WARNING: minor_str          */
     292    3, /* 0x0008 WARNING: array              */
     293    2, /* 0x0009 WARNING: above.             */
     294    3, /* 0x000a WARNING:                    */
     295    3, /* 0x000b WARNING: If you change      */
     296    3, /* 0x000c WARNING: that one,          */
     297    4, /* 0x000d WARNING: change this one    */
     298    4, /* 0x000e WARNING: too!!!             */
     299    4, /* 0x000f */
     300    4, /* 0x0010 */
     301    4, /* 0x0011 */
     302    4, /* 0x0012 */
     303    5, /* 0x0013 */
     304    4, /* 0x0014 */
     305    5, /* 0x0015 */
     306    5, /* 0x0016 */
     307    4, /* 0x0017 */
     308    6, /* 0x0018 */
     309    6, /* 0x0019 */
     310    7, /* 0x001a */
     311    6, /* 0x001b */
     312    6, /* 0x001c */
     313    7, /* 0x001d */
     314    7, /* 0x001e */
     315    0, /* 0x001f */
     316    0, /* 0x0020 */
     317    7, /* 0x0021 */
     318    6, /* 0x0022 */
     319    0  /* 0x0023-0xfffe */
    334320};
    335321
     
    341327#define NUM_CMD_FEAT_STR    48
    342328
    343 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
    344 static const char * const cmd_feat_str[] = {
     329#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
     330static const char *const cmd_feat_str[] = {
    345331    "",                 /* word 82 bit 15: obsolete  */
    346332    "NOP cmd",              /* word 82 bit 14 */
     
    359345    "Security Mode feature set",        /* word 82 bit  1 */
    360346    "SMART feature set",            /* word 82 bit  0 */
    361                         /* --------------*/
     347                        /* -------------- */
    362348    "",                 /* word 83 bit 15: !valid bit */
    363349    "",                 /* word 83 bit 14:  valid bit */
    364     "FLUSH CACHE EXT cmd",      /* word 83 bit 13 */
    365     "Mandatory FLUSH CACHE cmd ",   /* word 83 bit 12 */
     350    "FLUSH CACHE EXT cmd",          /* word 83 bit 13 */
     351    "Mandatory FLUSH CACHE cmd ",       /* word 83 bit 12 */
    366352    "Device Configuration Overlay feature set ",
    367353    "48-bit Address feature set ",      /* word 83 bit 10 */
     
    372358    "Power-Up In Standby feature set",  /* word 83 bit  5 */
    373359    "Removable Media Status Notification feature set",
    374     "Adv. Power Management feature set",/* word 83 bit  3 */
     360    "Adv. Power Management feature set",    /* word 83 bit  3 */
    375361    "CFA feature set",          /* word 83 bit  2 */
    376362    "READ/WRITE DMA QUEUED",        /* word 83 bit  1 */
    377363    "DOWNLOAD MICROCODE cmd",       /* word 83 bit  0 */
    378                         /* --------------*/
     364                        /* -------------- */
    379365    "",                 /* word 84 bit 15: !valid bit */
    380366    "",                 /* word 84 bit 14:  valid bit */
     
    408394
    409395/* words 89, 90, SECU ERASE TIME */
    410 #define ERASE_BITS      0x00ff
     396#define ERASE_BITS      0x00ff
    411397
    412398/* word 92: master password revision */
     
    414400
    415401/* word 93: hw reset result */
    416 #define CBLID           0x2000  /* CBLID status */
    417 #define RST0            0x0001  /* 1=reset to device #0 */
    418 #define DEV_DET         0x0006  /* how device num determined */
    419 #define JUMPER_VAL      0x0002  /* device num determined by jumper */
    420 #define CSEL_VAL        0x0004  /* device num determined by CSEL_VAL */
     402#define CBLID           0x2000  /* CBLID status */
     403#define RST0            0x0001  /* 1=reset to device #0 */
     404#define DEV_DET         0x0006  /* how device num determined */
     405#define JUMPER_VAL      0x0002  /* device num determined by jumper */
     406#define CSEL_VAL        0x0004  /* device num determined by CSEL_VAL */
    421407
    422408/* word 127: removable media status notification feature set support */
    423 #define RM_STAT_BITS        0x0003
    424 #define RM_STAT_SUP     0x0001
     409#define RM_STAT_BITS    0x0003
     410#define RM_STAT_SUP     0x0001
    425411
    426412/* word 128: security */
    427 #define SECU_ENABLED    0x0002
    428 #define SECU_LEVEL      0x0010
    429 #define NUM_SECU_STR    6
    430 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
    431 static const char * const secu_str[] = {
     413#define SECU_ENABLED    0x0002
     414#define SECU_LEVEL      0x0010
     415#define NUM_SECU_STR    6
     416#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
     417static const char *const secu_str[] = {
    432418    "supported",            /* word 128, bit 0 */
    433419    "enabled",          /* word 128, bit 1 */
     
    440426
    441427/* word 160: CFA power mode */
    442 #define VALID_W160      0x8000  /* 1=word valid */
    443 #define PWR_MODE_REQ        0x2000  /* 1=CFA power mode req'd by some cmds*/
    444 #define PWR_MODE_OFF        0x1000  /* 1=CFA power moded disabled */
    445 #define MAX_AMPS        0x0fff  /* value = max current in ma */
     428#define VALID_W160              0x8000  /* 1=word valid */
     429#define PWR_MODE_REQ            0x2000  /* 1=CFA power mode req'd by some cmds*/
     430#define PWR_MODE_OFF            0x1000  /* 1=CFA power moded disabled */
     431#define MAX_AMPS                0x0fff  /* value = max current in ma */
    446432
    447433/* word 255: integrity */
    448 #define SIG         0x00ff  /* signature location */
    449 #define SIG_VAL         0x00A5  /* signature value */
    450 
    451 #define TIMING_MB       64
    452 #define TIMING_BUF_MB       1
    453 #define TIMING_BUF_BYTES    (TIMING_BUF_MB * 1024 * 1024)
    454 #define TIMING_BUF_COUNT    (timing_MB / TIMING_BUF_MB)
    455 #define BUFCACHE_FACTOR     2
    456 
    457 #undef DO_FLUSHCACHE        /* under construction: force cache flush on -W0 */
     434#define SIG                     0x00ff  /* signature location */
     435#define SIG_VAL                 0x00a5  /* signature value */
     436
     437#define TIMING_MB               64
     438#define TIMING_BUF_MB           1
     439#define TIMING_BUF_BYTES        (TIMING_BUF_MB * 1024 * 1024)
     440#define BUFCACHE_FACTOR         2
     441
     442#undef DO_FLUSHCACHE            /* under construction: force cache flush on -W0 */
    458443
    459444/* Busybox messages and functions */
    460 static int bb_ioctl(int fd, int request, void *argp, const char *string)
    461 {
    462     int e = ioctl(fd, request, argp);
    463     if (e && string)
    464         bb_perror_msg(" %s", string);
    465     return e;
    466 }
    467 
    468 static int bb_ioctl_alt(int fd, int cmd, unsigned char *args, int alt, const char *string)
     445#if ENABLE_IOCTL_HEX2STR_ERROR
     446static int ioctl_alt_func(int fd, int cmd, unsigned char *args, int alt, const char *string)
    469447{
    470448    if (!ioctl(fd, cmd, args))
    471449        return 0;
    472450    args[0] = alt;
    473     return bb_ioctl(fd, cmd, args, string);
    474 }
    475 
    476 static void on_off(unsigned int value);
    477 
    478 static void print_flag_on_off(unsigned long get_arg, const char *s, unsigned long arg)
    479 {
    480 
    481     if (get_arg)
    482     {
     451    return bb_ioctl_or_warn(fd, cmd, args, string);
     452}
     453#define ioctl_alt_or_warn(fd,cmd,args,alt) ioctl_alt_func(fd,cmd,args,alt,#cmd)
     454#else
     455static int ioctl_alt_func(int fd, int cmd, unsigned char *args, int alt)
     456{
     457    if (!ioctl(fd, cmd, args))
     458        return 0;
     459    args[0] = alt;
     460    return bb_ioctl_or_warn(fd, cmd, args);
     461}
     462#define ioctl_alt_or_warn(fd,cmd,args,alt) ioctl_alt_func(fd,cmd,args,alt)
     463#endif
     464
     465static void on_off(int value)
     466{
     467    puts(value ? " (on)" : " (off)");
     468}
     469
     470static void print_flag_on_off(int get_arg, const char *s, unsigned long arg)
     471{
     472    if (get_arg) {
    483473        printf(" setting %s to %ld", s, arg);
    484474        on_off(arg);
     
    486476}
    487477
    488 static void bb_ioctl_on_off(int fd, int request, void *argp, const char *string,
    489                              const char * str)
    490 {
    491     if (ioctl(fd, request, &argp) != 0)
    492         bb_perror_msg(" %s", string);
    493     else
    494     {
    495         printf(" %s\t= %2ld", str, (unsigned long) argp);
    496         on_off((unsigned long) argp);
    497     }
    498 }
    499 
    500 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
     478static void print_value_on_off(const char *str, unsigned long argp)
     479{
     480    printf(" %s\t= %2ld", str, argp);
     481    on_off(argp != 0);
     482}
     483
     484#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
    501485static void print_ascii(uint16_t *p, uint8_t length);
    502486
    503 static void xprint_ascii(uint16_t *val ,int i, char * string, int n)
    504 {
    505     if (val[i])
    506     {
    507         printf("\t%-20s",string);
     487static void xprint_ascii(uint16_t *val, int i, const char *string, int n)
     488{
     489    if (val[i]) {
     490        printf("\t%-20s", string);
    508491        print_ascii(&val[i], n);
    509492    }
    510493}
    511494#endif
    512 /* end of  busybox specific stuff */
    513 
    514 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
     495/* end of busybox specific stuff */
     496
     497#if ENABLE_FEATURE_HDPARM_GET_IDENTITY
    515498static uint8_t mode_loop(uint16_t mode_sup, uint16_t mode_sel, int cc, uint8_t *have_mode)
    516499{
     
    518501    uint8_t err_dma = 0;
    519502
    520     for (ii = 0; ii <= MODE_MAX; ii++)
    521     {
    522         if (mode_sel & 0x0001)
    523         {
    524             printf("*%cdma%u ",cc,ii);
     503    for (ii = 0; ii <= MODE_MAX; ii++) {
     504        if (mode_sel & 0x0001) {
     505            printf("*%cdma%u ", cc, ii);
    525506            if (*have_mode)
    526507                err_dma = 1;
    527508            *have_mode = 1;
    528         }
    529         else if (mode_sup & 0x0001)
    530             printf("%cdma%u ",cc,ii);
    531 
    532         mode_sup >>=1;
    533         mode_sel >>=1;
     509        } else if (mode_sup & 0x0001)
     510            printf("%cdma%u ", cc, ii);
     511
     512        mode_sup >>= 1;
     513        mode_sel >>= 1;
    534514    }
    535515    return err_dma;
    536516}
    537517
    538 static void print_ascii(uint16_t *p, uint8_t length) {
     518static void print_ascii(uint16_t *p, uint8_t length)
     519{
    539520    uint8_t ii;
    540521    char cl;
    541522
    542523    /* find first non-space & print it */
    543     for (ii = 0; ii< length; ii++)
    544     {
    545         if (((char) 0x00ff&((*p)>>8)) != ' ')
     524    for (ii = 0; ii < length; ii++) {
     525        if ((char)((*p)>>8) != ' ')
    546526            break;
    547         if ((cl = (char) 0x00ff&(*p)) != ' ')
    548         {
    549             if (cl != '\0') printf("%c",cl);
     527        cl = (char)(*p);
     528        if (cl != ' ') {
     529            if (cl != '\0')
     530                printf("%c", cl);
    550531            p++;
    551532            ii++;
     
    555536    }
    556537    /* print the rest */
    557     for (; ii< length; ii++)
    558     {
     538    for (; ii< length; ii++) {
    559539        if (!(*p))
    560540            break; /* some older devices have NULLs */
    561         printf("%c%c",(char)0x00ff&((*p)>>8),(char)(*p)&0x00ff);
     541        printf("%c%c", (char)((*p)>>8), (char)(*p));
    562542        p++;
    563543    }
    564     printf("\n");
     544    puts("");
    565545}
    566546
     
    584564        swab(id_supplied, buf, sizeof(buf));
    585565        val = buf;
    586     } else val = id_supplied;
     566    } else
     567        val = id_supplied;
    587568
    588569    chksum &= 0xff;
    589570
    590571    /* check if we recognise the device type */
    591     printf("\n");
    592     if(!(val[GEN_CONFIG] & NOT_ATA))
    593     {
     572    puts("");
     573    if (!(val[GEN_CONFIG] & NOT_ATA)) {
    594574        dev = ATA_DEV;
    595575        printf("ATA device, with ");
    596     }
    597     else if(val[GEN_CONFIG]==CFA_SUPPORT_VAL)
    598     {
     576    } else if (val[GEN_CONFIG]==CFA_SUPPORT_VAL) {
    599577        dev = ATA_DEV;
    600578        like_std = 4;
    601579        printf("CompactFlash ATA device, with ");
    602     }
    603     else if(!(val[GEN_CONFIG] & NOT_ATAPI))
    604     {
     580    } else if (!(val[GEN_CONFIG] & NOT_ATAPI)) {
    605581        dev = ATAPI_DEV;
    606582        eqpt = (val[GEN_CONFIG] & EQPT_TYPE) >> SHIFT_EQPT;
    607583        printf("ATAPI %s, with ", pkt_str[eqpt]);
    608584        like_std = 3;
    609     }
    610     else
     585    } else
    611586        /*"Unknown device type:\n\tbits 15&14 of general configuration word 0 both set to 1.\n"*/
    612         bb_error_msg_and_die("Unknown device type");
     587        bb_error_msg_and_die("unknown device type");
    613588
    614589    printf("%sremovable media\n", !(val[GEN_CONFIG] & MEDIA_REMOVABLE) ? "non-" : "");
     
    620595     * know yet what standard this device is using.
    621596     */
    622     if ((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL) ||
    623        (val[CONFIG]==PWRD_NID_VAL) || (val[CONFIG]==PWRD_ID_VAL) )
    624     {
     597    if ((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL)
     598     || (val[CONFIG]==PWRD_NID_VAL) || (val[CONFIG]==PWRD_ID_VAL)
     599    ) {
    625600        like_std = 5;
    626         if((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL))
     601        if ((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==STBY_ID_VAL))
    627602            printf("powers-up in standby; SET FEATURES subcmd spins-up.\n");
    628         if(((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==PWRD_NID_VAL)) && (val[GEN_CONFIG] & INCOMPLETE))
     603        if (((val[CONFIG]==STBY_NID_VAL) || (val[CONFIG]==PWRD_NID_VAL)) && (val[GEN_CONFIG] & INCOMPLETE))
    629604            printf("\n\tWARNING: ID response incomplete.\n\tFollowing data may be incorrect.\n\n");
    630605    }
     
    640615     * defined until ATA-3 & the CDROM std uses different words.) */
    641616    printf("Standards:");
    642     if (eqpt != CDROM)
    643     {
    644         if (val[MINOR] && (val[MINOR] <= MINOR_MAX))
    645         {
    646             if(like_std < 3) like_std = 3;
     617    if (eqpt != CDROM) {
     618        if (val[MINOR] && (val[MINOR] <= MINOR_MAX)) {
     619            if (like_std < 3) like_std = 3;
    647620            std = actual_ver[val[MINOR]];
    648             if(std) printf("\n\tUsed: %s ",minor_str[val[MINOR]]);
     621            if (std) printf("\n\tUsed: %s ", minor_str[val[MINOR]]);
    649622
    650623        }
     
    652625         * thus, only the newest 4 issues need be supported. (That's
    653626         * what "kk" and "min_std" are all about.) */
    654         if (val[MAJOR] && (val[MAJOR] !=NOVAL_1))
    655         {
     627        if (val[MAJOR] && (val[MAJOR] != NOVAL_1)) {
    656628            printf("\n\tSupported: ");
    657629            jj = val[MAJOR] << 1;
    658630            kk = like_std >4 ? like_std-4: 0;
    659             for (ii = 14; (ii >0)&&(ii>kk); ii--)
    660             {
    661                 if (jj & 0x8000)
    662                 {
     631            for (ii = 14; (ii >0)&&(ii>kk); ii--) {
     632                if (jj & 0x8000) {
    663633                    printf("%u ", ii);
    664                     if (like_std < ii)
    665                     {
     634                    if (like_std < ii) {
    666635                        like_std = ii;
    667636                        kk = like_std >4 ? like_std-4: 0;
    668637                    }
    669                     if(min_std > ii) min_std = ii;
     638                    if (min_std > ii) min_std = ii;
    670639                }
    671640                jj <<= 1;
    672641            }
    673             if(like_std < 3) like_std = 3;
     642            if (like_std < 3) like_std = 3;
    674643        }
    675644        /* Figure out what standard the device is using if it hasn't told
     
    677646         * the words from the next level up.  It happens.
    678647         */
    679         if(like_std < std) like_std = std;
     648        if (like_std < std) like_std = std;
    680649
    681650        if (((std == 5) || (!std && (like_std < 6))) &&
     
    683652            ((  val[CMDS_SUPP_1] & CMDS_W83) > 0x00ff)) ||
    684653            ((( val[CMDS_SUPP_2] & VALID) == VALID_VAL) &&
    685             (   val[CMDS_SUPP_2] & CMDS_W84) ) ) )
    686         {
     654            (   val[CMDS_SUPP_2] & CMDS_W84) ) )
     655        ) {
    687656            like_std = 6;
    688         }
    689         else if (((std == 4) || (!std && (like_std < 5))) &&
     657        } else if (((std == 4) || (!std && (like_std < 5))) &&
    690658            ((((val[INTEGRITY]  & SIG) == SIG_VAL) && !chksum) ||
    691659            ((  val[HWRST_RSLT] & VALID) == VALID_VAL) ||
     
    694662        {
    695663            like_std = 5;
    696         }
    697         else if (((std == 3) || (!std && (like_std < 4))) &&
     664        } else if (((std == 3) || (!std && (like_std < 4))) &&
    698665                ((((val[CMDS_SUPP_1] & VALID) == VALID_VAL) &&
    699666                ((( val[CMDS_SUPP_1] & CMDS_W83) > 0x0000) ||
     
    701668                ((  val[CAPAB_1] & VALID) == VALID_VAL) ||
    702669                ((  val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA]) ||
    703                 ((  val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP) ) )
    704         {
     670                ((  val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP) )
     671        ) {
    705672            like_std = 4;
    706         }
    707         else if (((std == 2) || (!std && (like_std < 3))) &&
    708                ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) )
    709         {
     673        } else if (((std == 2) || (!std && (like_std < 3)))
     674         && ((val[CMDS_SUPP_1] & VALID) == VALID_VAL)
     675        ) {
    710676            like_std = 3;
    711         }
    712         else if (((std == 1) || (!std && (like_std < 2))) &&
     677        } else if (((std == 1) || (!std && (like_std < 2))) &&
    713678                ((val[CAPAB_0] & (IORDY_SUP | IORDY_OFF)) ||
    714679                (val[WHATS_VALID] & OK_W64_70)) )
     
    716681            like_std = 2;
    717682        }
     683
    718684        if (!std)
    719             printf("\n\tLikely used: %u\n",like_std);
     685            printf("\n\tLikely used: %u\n", like_std);
    720686        else if (like_std > std)
    721             printf("& some of %u\n",like_std);
     687            printf("& some of %u\n", like_std);
    722688        else
    723             printf("\n");
    724     }
    725     else
    726     {
     689            puts("");
     690    } else {
    727691        /* TBD: do CDROM stuff more thoroughly.  For now... */
    728692        kk = 0;
    729         if (val[CDR_MINOR] == 9)
    730         {
     693        if (val[CDR_MINOR] == 9) {
    731694            kk = 1;
    732695            printf("\n\tUsed: ATAPI for CD-ROMs, SFF-8020i, r2.5");
    733696        }
    734         if (val[CDR_MAJOR] && (val[CDR_MAJOR] !=NOVAL_1))
    735         {
     697        if (val[CDR_MAJOR] && (val[CDR_MAJOR] !=NOVAL_1)) {
    736698            kk = 1;
    737699            printf("\n\tSupported: CD-ROM ATAPI");
    738700            jj = val[CDR_MAJOR] >> 1;
    739             for (ii = 1; ii <15; ii++)
    740             {
    741                 if(jj & 0x0001) printf("-%u ", ii);
     701            for (ii = 1; ii < 15; ii++) {
     702                if (jj & 0x0001) printf("-%u ", ii);
    742703                jj >>= 1;
    743704            }
    744705        }
    745         printf("%s\n", (!kk) ? "\n\tLikely used CD-ROM ATAPI-1" : "" );
     706        printf("%s\n", kk ? "" : "\n\tLikely used CD-ROM ATAPI-1");
    746707        /* the cdrom stuff is more like ATA-2 than anything else, so: */
    747708        like_std = 2;
     
    753714    printf("Configuration:\n");
    754715    /* more info from the general configuration word */
    755     if ((eqpt != CDROM) && (like_std == 1))
    756     {
     716    if ((eqpt != CDROM) && (like_std == 1)) {
    757717        jj = val[GEN_CONFIG] >> 1;
    758         for (ii = 1; ii < 15; ii++)
    759         {
    760             if(jj & 0x0001) printf("\t%s\n",ata1_cfg_str[ii]);
     718        for (ii = 1; ii < 15; ii++) {
     719            if (jj & 0x0001)
     720                printf("\t%s\n", ata1_cfg_str[ii]);
    761721            jj >>=1;
    762722        }
    763723    }
    764     if (dev == ATAPI_DEV)
    765     {
     724    if (dev == ATAPI_DEV) {
    766725        if ((val[GEN_CONFIG] & DRQ_RESPONSE_TIME) ==  DRQ_3MS_VAL)
    767726            strng = "3ms";
     
    770729        else if ((val[GEN_CONFIG] & DRQ_RESPONSE_TIME) ==  DRQ_50US_VAL)
    771730            strng ="50us";
    772         else 
     731        else
    773732            strng = "Unknown";
    774733        printf("\tDRQ response: %s\n\tPacket size: ", strng); /* Data Request (DRQ) */
     
    781740            strng = "Unknown";
    782741        puts(strng);
    783     }
    784     else
    785     {
     742    } else {
    786743        /* addressing...CHS? See section 6.2 of ATA specs 4 or 5 */
    787744        ll = (uint32_t)val[LBA_SECTS_MSB] << 16 | val[LBA_SECTS_LSB];
    788745        mm = 0; bbbig = 0;
    789         if ( (ll > 0x00FBFC10) && (!val[LCYLS]))
     746        if ((ll > 0x00FBFC10) && (!val[LCYLS]))
    790747            printf("\tCHS addressing not supported\n");
    791         else
    792         {
     748        else {
    793749            jj = val[WHATS_VALID] & OK_W54_58;
    794750            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",
     
    796752
    797753            if ((min_std == 1) && (val[TRACK_BYTES] || val[SECT_BYTES]))
    798                 printf("\tbytes/track: %u\tbytes/sector: %u\n",val[TRACK_BYTES], val[SECT_BYTES]);
    799 
    800             if (jj)
    801             {
     754                printf("\tbytes/track: %u\tbytes/sector: %u\n", val[TRACK_BYTES], val[SECT_BYTES]);
     755
     756            if (jj) {
    802757                mm = (uint32_t)val[CAPACITY_MSB] << 16 | val[CAPACITY_LSB];
    803                 if (like_std < 3)
    804                 {
    805                      /* check Endian of capacity bytes */
     758                if (like_std < 3) {
     759                    /* check Endian of capacity bytes */
    806760                    nn = val[LCYLS_CUR] * val[LHEADS_CUR] * val[LSECTS_CUR];
    807761                    oo = (uint32_t)val[CAPACITY_LSB] << 16 | val[CAPACITY_MSB];
     
    809763                        mm = oo;
    810764                }
    811                 printf("\tCHS current addressable sectors:%11u\n",mm);
     765                printf("\tCHS current addressable sectors:%11u\n", mm);
    812766            }
    813767        }
    814768        /* LBA addressing */
    815         printf("\tLBA    user addressable sectors:%11u\n",ll);
    816         if ( ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) &&
    817              (val[CMDS_SUPP_1] & SUPPORT_48_BIT) )
    818         {
    819             bbbig = (uint64_t)val[LBA_64_MSB]   << 48 |
    820                     (uint64_t)val[LBA_48_MSB]   << 32 |
    821                     (uint64_t)val[LBA_MID]  << 16 |
    822                     val[LBA_LSB] ;
    823             printf("\tLBA48  user addressable sectors:%11"PRIu64"\n",bbbig);
     769        printf("\tLBA    user addressable sectors:%11u\n", ll);
     770        if (((val[CMDS_SUPP_1] & VALID) == VALID_VAL)
     771         && (val[CMDS_SUPP_1] & SUPPORT_48_BIT)
     772        ) {
     773            bbbig = (uint64_t)val[LBA_64_MSB] << 48 |
     774                    (uint64_t)val[LBA_48_MSB] << 32 |
     775                    (uint64_t)val[LBA_MID] << 16 |
     776                    val[LBA_LSB];
     777            printf("\tLBA48  user addressable sectors:%11"PRIu64"\n", bbbig);
    824778        }
    825779
    826780        if (!bbbig)
    827781            bbbig = (uint64_t)(ll>mm ? ll : mm); /* # 512 byte blocks */
    828         printf("\tdevice size with M = 1024*1024: %11"PRIu64" MBytes\n",bbbig>>11);
    829         bbbig = (bbbig<<9)/1000000;
    830         printf("\tdevice size with M = 1000*1000: %11"PRIu64" MBytes ",bbbig);
     782        printf("\tdevice size with M = 1024*1024: %11"PRIu64" MBytes\n", bbbig>>11);
     783        bbbig = (bbbig << 9) / 1000000;
     784        printf("\tdevice size with M = 1000*1000: %11"PRIu64" MBytes ", bbbig);
    831785
    832786        if (bbbig > 1000)
    833787            printf("(%"PRIu64" GB)\n", bbbig/1000);
    834         else 
    835             printf("\n");
     788        else
     789            puts("");
    836790    }
    837791
     
    839793    printf("Capabilities:\n\t");
    840794
    841     if (dev == ATAPI_DEV)
    842     {
     795    if (dev == ATAPI_DEV) {
    843796        if (eqpt != CDROM && (val[CAPAB_0] & CMD_Q_SUP)) printf("Cmd queuing, ");
    844797        if (val[CAPAB_0] & OVLP_SUP) printf("Cmd overlap, ");
     
    846799    if (val[CAPAB_0] & LBA_SUP) printf("LBA, ");
    847800
    848     if (like_std != 1)
    849     {
    850         printf("IORDY%s(can%s be disabled)\n",
    851                 !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "",
     801    if (like_std != 1) {
     802        printf("IORDY%s(can%s be disabled)\n",
     803                !(val[CAPAB_0] & IORDY_SUP) ? "(may be)" : "",
    852804                (val[CAPAB_0] & IORDY_OFF) ? "" :"not");
    853     }
    854     else
     805    } else
    855806        printf("no IORDY\n");
    856807
    857     if ((like_std == 1) && val[BUF_TYPE])
    858     {
     808    if ((like_std == 1) && val[BUF_TYPE]) {
    859809        printf("\tBuffer type: %04x: %s%s\n", val[BUF_TYPE],
    860                 (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector", 
     810                (val[BUF_TYPE] < 2) ? "single port, single-sector" : "dual port, multi-sector",
    861811                (val[BUF_TYPE] > 2) ? " with read caching ability" : "");
    862812    }
    863813
    864     if ((min_std == 1) && (val[BUFFER__SIZE] && (val[BUFFER__SIZE] != NOVAL_1)))
    865     {
    866         printf("\tBuffer size: %.1fkB\n",(float)val[BUFFER__SIZE]/2);
    867     }
    868     if ((min_std < 4) && (val[RW_LONG]))
    869     {
    870         printf("\tbytes avail on r/w long: %u\n",val[RW_LONG]);
    871     }
    872     if ((eqpt != CDROM) && (like_std > 3))
    873     {
    874         printf("\tQueue depth: %u\n",(val[QUEUE_DEPTH] & DEPTH_BITS)+1);
    875     }
    876 
    877     if (dev == ATA_DEV)
    878     {
     814    if ((min_std == 1) && (val[BUFFER__SIZE] && (val[BUFFER__SIZE] != NOVAL_1))) {
     815        printf("\tBuffer size: %.1fkB\n", (float)val[BUFFER__SIZE]/2);
     816    }
     817    if ((min_std < 4) && (val[RW_LONG])) {
     818        printf("\tbytes avail on r/w long: %u\n", val[RW_LONG]);
     819    }
     820    if ((eqpt != CDROM) && (like_std > 3)) {
     821        printf("\tQueue depth: %u\n", (val[QUEUE_DEPTH] & DEPTH_BITS) + 1);
     822    }
     823
     824    if (dev == ATA_DEV) {
    879825        if (like_std == 1)
    880             printf("\tCan%s perform double-word IO\n",(!val[DWORD_IO]) ?"not":"");
    881         else
    882         {
     826            printf("\tCan%s perform double-word IO\n", (!val[DWORD_IO]) ? "not" : "");
     827        else {
    883828            printf("\tStandby timer values: spec'd by %s", (val[CAPAB_0] & STD_STBY) ? "Standard" : "Vendor");
    884829            if ((like_std > 3) && ((val[CAPAB_1] & VALID) == VALID_VAL))
    885                 printf(", %s device specific minimum\n",(val[CAPAB_1] & MIN_STANDBY_TIMER)?"with":"no");
     830                printf(", %s device specific minimum\n", (val[CAPAB_1] & MIN_STANDBY_TIMER) ? "with" : "no");
    886831            else
    887               printf("\n");
     832                puts("");
    888833        }
    889834        printf("\tR/W multiple sector transfer: ");
    890835        if ((like_std < 3) && !(val[SECTOR_XFER_MAX] & SECTOR_XFER))
    891836            printf("not supported\n");
    892         else
    893         {
    894             printf("Max = %u\tCurrent = ",val[SECTOR_XFER_MAX] & SECTOR_XFER);
     837        else {
     838            printf("Max = %u\tCurrent = ", val[SECTOR_XFER_MAX] & SECTOR_XFER);
    895839            if (val[SECTOR_XFER_CUR] & MULTIPLE_SETTING_VALID)
    896840                printf("%u\n", val[SECTOR_XFER_CUR] & SECTOR_XFER);
     
    898842                printf("?\n");
    899843        }
    900         if ((like_std > 3) && (val[CMDS_SUPP_1] & 0x0008))
    901         {
     844        if ((like_std > 3) && (val[CMDS_SUPP_1] & 0x0008)) {
    902845            /* We print out elsewhere whether the APM feature is enabled or
    903846               not.  If it's not enabled, let's not repeat the info; just print
    904847               nothing here. */
    905848            printf("\tAdvancedPM level: ");
    906             if ( (val[ADV_PWR] & 0xFF00) == 0x4000 )
    907             {
     849            if ((val[ADV_PWR] & 0xFF00) == 0x4000) {
    908850                uint8_t apm_level = val[ADV_PWR] & 0x00FF;
    909851                printf("%u (0x%x)\n", apm_level, apm_level);
     
    914856        if (like_std > 5 && val[ACOUSTIC]) {
    915857            printf("\tRecommended acoustic management value: %u, current value: %u\n",
    916                                     (val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff);
    917         }
    918     }
    919     else
    920     {
     858                    (val[ACOUSTIC] >> 8) & 0x00ff, val[ACOUSTIC] & 0x00ff);
     859        }
     860    } else {
    921861         /* ATAPI */
    922862        if (eqpt != CDROM && (val[CAPAB_0] & SWRST_REQ))
    923863            printf("\tATA sw reset required\n");
    924864
    925         if (val[PKT_REL] || val[SVC_NBSY])
    926         {
     865        if (val[PKT_REL] || val[SVC_NBSY]) {
    927866            printf("\tOverlap support:");
    928             if (val[PKT_REL]) printf(" %uus to release bus.",val[PKT_REL]);
    929             if (val[SVC_NBSY]) printf(" %uus to clear BSY after SERVICE cmd.",val[SVC_NBSY]);
    930             printf("\n");
     867            if (val[PKT_REL]) printf(" %uus to release bus.", val[PKT_REL]);
     868            if (val[SVC_NBSY]) printf(" %uus to clear BSY after SERVICE cmd.", val[SVC_NBSY]);
     869            puts("");
    931870        }
    932871    }
     
    936875    if (!(val[CAPAB_0] & DMA_SUP))
    937876        printf("not supported\n");
    938     else
    939     {
     877    else {
    940878        if (val[DMA_MODE] && !val[SINGLE_DMA] && !val[MULTI_DMA])
    941             printf(" sdma%u\n",(val[DMA_MODE] & MODE) >> 8);
    942         if (val[SINGLE_DMA])
    943         {
     879            printf(" sdma%u\n", (val[DMA_MODE] & MODE) >> 8);
     880        if (val[SINGLE_DMA]) {
    944881            jj = val[SINGLE_DMA];
    945882            kk = val[SINGLE_DMA] >> 8;
    946             err_dma += mode_loop(jj,kk,'s',&have_mode);
    947         }
    948         if (val[MULTI_DMA])
    949         {
     883            err_dma += mode_loop(jj, kk, 's', &have_mode);
     884        }
     885        if (val[MULTI_DMA]) {
    950886            jj = val[MULTI_DMA];
    951887            kk = val[MULTI_DMA] >> 8;
    952             err_dma += mode_loop(jj,kk,'m',&have_mode);
    953         }
    954         if ((val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA])
    955         {
     888            err_dma += mode_loop(jj, kk, 'm', &have_mode);
     889        }
     890        if ((val[WHATS_VALID] & OK_W88) && val[ULTRA_DMA]) {
    956891            jj = val[ULTRA_DMA];
    957892            kk = val[ULTRA_DMA] >> 8;
    958             err_dma += mode_loop(jj,kk,'u',&have_mode);
     893            err_dma += mode_loop(jj, kk, 'u', &have_mode);
    959894        }
    960895        if (err_dma || !have_mode) printf("(?)");
    961         printf("\n");
     896        puts("");
    962897
    963898        if ((dev == ATAPI_DEV) && (eqpt != CDROM) && (val[CAPAB_0] & DMA_IL_SUP))
    964899            printf("\t\tInterleaved DMA support\n");
    965900
    966         if ((val[WHATS_VALID] & OK_W64_70) &&
    967            (val[DMA_TIME_MIN] || val[DMA_TIME_NORM]))
    968         {
     901        if ((val[WHATS_VALID] & OK_W64_70)
     902         && (val[DMA_TIME_MIN] || val[DMA_TIME_NORM])
     903        ) {
    969904            printf("\t\tCycle time:");
    970             if (val[DMA_TIME_MIN]) printf(" min=%uns",val[DMA_TIME_MIN]);
    971             if (val[DMA_TIME_NORM]) printf(" recommended=%uns",val[DMA_TIME_NORM]);
    972             printf("\n");
     905            if (val[DMA_TIME_MIN]) printf(" min=%uns", val[DMA_TIME_MIN]);
     906            if (val[DMA_TIME_NORM]) printf(" recommended=%uns", val[DMA_TIME_NORM]);
     907            puts("");
    973908        }
    974909    }
     
    978913    /* If a drive supports mode n (e.g. 3), it also supports all modes less
    979914     * than n (e.g. 3, 2, 1 and 0).  Print all the modes. */
    980     if ((val[WHATS_VALID] & OK_W64_70) && (val[ADV_PIO_MODES] & PIO_SUP))
    981     {
     915    if ((val[WHATS_VALID] & OK_W64_70) && (val[ADV_PIO_MODES] & PIO_SUP)) {
    982916        jj = ((val[ADV_PIO_MODES] & PIO_SUP) << 3) | 0x0007;
    983         for (ii = 0; ii <= PIO_MODE_MAX ; ii++)
    984         {
    985             if (jj & 0x0001) printf("pio%d ",ii);
     917        for (ii = 0; ii <= PIO_MODE_MAX; ii++) {
     918            if (jj & 0x0001) printf("pio%d ", ii);
    986919            jj >>=1;
    987920        }
    988         printf("\n");
    989     }
    990     else if (((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE) )
    991     {
     921        puts("");
     922    } else if (((min_std < 5) || (eqpt == CDROM)) && (val[PIO_MODE] & MODE)) {
    992923        for (ii = 0; ii <= val[PIO_MODE]>>8; ii++)
    993             printf("pio%d ",ii);
    994         printf("\n");
    995     }
    996     else
     924            printf("pio%d ", ii);
     925        puts("");
     926    } else
    997927        printf("unknown\n");
    998928
    999     if (val[WHATS_VALID] & OK_W64_70)
    1000     {
    1001         if (val[PIO_NO_FLOW] || val[PIO_FLOW])
    1002         {
     929    if (val[WHATS_VALID] & OK_W64_70) {
     930        if (val[PIO_NO_FLOW] || val[PIO_FLOW]) {
    1003931            printf("\t\tCycle time:");
    1004932            if (val[PIO_NO_FLOW]) printf(" no flow control=%uns", val[PIO_NO_FLOW]);
    1005933            if (val[PIO_FLOW]) printf("  IORDY flow control=%uns", val[PIO_FLOW]);
    1006             printf("\n");
    1007         }
    1008     }
    1009 
    1010     if ((val[CMDS_SUPP_1] & VALID) == VALID_VAL)
    1011     {
     934            puts("");
     935        }
     936    }
     937
     938    if ((val[CMDS_SUPP_1] & VALID) == VALID_VAL) {
    1012939        printf("Commands/features:\n\tEnabled\tSupported:\n");
    1013940        jj = val[CMDS_SUPP_0];
    1014941        kk = val[CMDS_EN_0];
    1015         for (ii = 0; ii < NUM_CMD_FEAT_STR; ii++)
    1016         {
    1017             if ((jj & 0x8000) && (*cmd_feat_str[ii] != '\0'))
    1018             {
     942        for (ii = 0; ii < NUM_CMD_FEAT_STR; ii++) {
     943            if ((jj & 0x8000) && (*cmd_feat_str[ii] != '\0')) {
    1019944                printf("\t%s\t%s\n", (kk & 0x8000) ? "   *" : "", cmd_feat_str[ii]);
    1020945            }
    1021             jj <<=1; kk<<=1;
    1022             if (ii%16 == 15)
    1023             {
     946            jj <<= 1;
     947            kk <<= 1;
     948            if (ii % 16 == 15) {
    1024949                jj = val[CMDS_SUPP_0+1+(ii/16)];
    1025950                kk = val[CMDS_EN_0+1+(ii/16)];
    1026951            }
    1027             if (ii == 31)
    1028             {
     952            if (ii == 31) {
    1029953                if ((val[CMDS_SUPP_2] & VALID) != VALID_VAL)
    1030954                    ii +=16;
     
    1033957    }
    1034958    /* Removable Media Status Notification feature set */
    1035     if((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP)
     959    if ((val[RM_STAT] & RM_STAT_BITS) == RM_STAT_SUP)
    1036960        printf("\t%s supported\n", cmd_feat_str[27]);
    1037961
    1038 
    1039962    /* security */
    1040     if ((eqpt != CDROM) && (like_std > 3) &&
    1041        (val[SECU_STATUS] || val[ERASE_TIME] || val[ENH_ERASE_TIME]))
    1042     {
     963    if ((eqpt != CDROM) && (like_std > 3)
     964     && (val[SECU_STATUS] || val[ERASE_TIME] || val[ENH_ERASE_TIME])
     965    ) {
    1043966        printf("Security:\n");
    1044967        if (val[PSWD_CODE] && (val[PSWD_CODE] != NOVAL_1))
    1045             printf("\tMaster password revision code = %u\n",val[PSWD_CODE]);
     968            printf("\tMaster password revision code = %u\n", val[PSWD_CODE]);
    1046969        jj = val[SECU_STATUS];
    1047         if (jj)
    1048         {
    1049             for (ii = 0; ii < NUM_SECU_STR; ii++)
    1050             {
     970        if (jj) {
     971            for (ii = 0; ii < NUM_SECU_STR; ii++) {
    1051972                printf("\t%s\t%s\n", (!(jj & 0x0001)) ? "not" : "",  secu_str[ii]);
    1052973                jj >>=1;
    1053974            }
    1054             if (val[SECU_STATUS] & SECU_ENABLED)
    1055             {
     975            if (val[SECU_STATUS] & SECU_ENABLED) {
    1056976                printf("\tSecurity level %s\n", (val[SECU_STATUS] & SECU_LEVEL) ? "maximum" : "high");
    1057977            }
     
    1059979        jj =  val[ERASE_TIME]     & ERASE_BITS;
    1060980        kk =  val[ENH_ERASE_TIME] & ERASE_BITS;
    1061         if (jj || kk)
    1062         {
     981        if (jj || kk) {
    1063982            printf("\t");
    1064983            if (jj) printf("%umin for %sSECURITY ERASE UNIT. ", jj==ERASE_BITS ? 508 : jj<<1, "");
    1065984            if (kk) printf("%umin for %sSECURITY ERASE UNIT. ", kk==ERASE_BITS ? 508 : kk<<1, "ENHANCED ");
    1066             printf("\n");
     985            puts("");
    1067986        }
    1068987    }
     
    1070989    /* reset result */
    1071990    jj = val[HWRST_RSLT];
    1072     if ((jj & VALID) == VALID_VAL)
    1073     {
     991    if ((jj & VALID) == VALID_VAL) {
    1074992        if (!(oo = (jj & RST0)))
    1075993            jj >>= 8;
     
    1078996        else if ((jj & DEV_DET) == CSEL_VAL)
    1079997            strng = " determined by CSEL";
    1080         else 
     998        else
    1081999            strng = "";
    1082         printf("HW reset results:\n\tCBLID- %s Vih\n\tDevice num = %i%s\n", 
     1000        printf("HW reset results:\n\tCBLID- %s Vih\n\tDevice num = %i%s\n",
    10831001                (val[HWRST_RSLT] & CBLID) ? "above" : "below", !(oo), strng);
    10841002    }
    10851003
    10861004    /* more stuff from std 5 */
    1087     if ((like_std > 4) && (eqpt != CDROM))
    1088     {
    1089         if (val[CFA_PWR_MODE] & VALID_W160)
    1090         {
     1005    if ((like_std > 4) && (eqpt != CDROM)) {
     1006        if (val[CFA_PWR_MODE] & VALID_W160) {
    10911007            printf("CFA power mode 1:\n\t%s%s\n", (val[CFA_PWR_MODE] & PWR_MODE_OFF) ? "disabled" : "enabled",
    1092                                         (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : "");
    1093 
    1094             if (val[CFA_PWR_MODE] & MAX_AMPS) printf("\tMaximum current = %uma\n",val[CFA_PWR_MODE] & MAX_AMPS);
    1095         }
    1096         if ((val[INTEGRITY] & SIG) == SIG_VAL)
    1097         {
     1008                    (val[CFA_PWR_MODE] & PWR_MODE_REQ) ? " and required by some commands" : "");
     1009
     1010            if (val[CFA_PWR_MODE] & MAX_AMPS)
     1011                printf("\tMaximum current = %uma\n", val[CFA_PWR_MODE] & MAX_AMPS);
     1012        }
     1013        if ((val[INTEGRITY] & SIG) == SIG_VAL) {
    10981014            printf("Checksum: %scorrect\n", chksum ? "in" : "");
    10991015        }
     
    11041020#endif
    11051021
    1106 static int get_identity, get_geom;
    1107 static int do_flush;
    1108 static int do_ctimings, do_timings;
    1109 static unsigned long set_readahead, get_readahead, Xreadahead;
    1110 static unsigned long set_readonly, get_readonly, readonly;
    1111 static unsigned long set_unmask, get_unmask, unmask;
    1112 static unsigned long set_mult, get_mult, mult;
    1113 #ifdef CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA
    1114 static unsigned long set_dma, get_dma, dma;
    1115 #endif
    1116 static unsigned long set_dma_q, get_dma_q, dma_q;
    1117 static unsigned long set_nowerr, get_nowerr, nowerr;
    1118 static unsigned long set_keep, get_keep, keep;
    1119 static unsigned long set_io32bit, get_io32bit, io32bit;
    1120 static unsigned long set_piomode, noisy_piomode;
     1022static smallint get_identity, get_geom;
     1023static smallint do_flush;
     1024static smallint do_ctimings, do_timings;
     1025static smallint reread_partn;
     1026
     1027static smallint set_piomode, noisy_piomode;
     1028static smallint set_readahead, get_readahead;
     1029static smallint set_readonly, get_readonly;
     1030static smallint set_unmask, get_unmask;
     1031static smallint set_mult, get_mult;
     1032static smallint set_dma_q, get_dma_q;
     1033static smallint set_nowerr, get_nowerr;
     1034static smallint set_keep, get_keep;
     1035static smallint set_io32bit, get_io32bit;
    11211036static int piomode;
     1037static unsigned long Xreadahead;
     1038static unsigned long readonly;
     1039static unsigned long unmask;
     1040static unsigned long mult;
     1041static unsigned long dma_q;
     1042static unsigned long nowerr;
     1043static unsigned long keep;
     1044static unsigned long io32bit;
     1045#if ENABLE_FEATURE_HDPARM_HDIO_GETSET_DMA
     1046static unsigned long dma;
     1047static smallint set_dma, get_dma;
     1048#endif
    11221049#ifdef HDIO_DRIVE_CMD
    1123 static unsigned long set_dkeep, get_dkeep, dkeep;
    1124 static unsigned long set_standby, get_standby, standby_requested;
    1125 static unsigned long set_xfermode, get_xfermode;
     1050static smallint set_xfermode, get_xfermode;
     1051static smallint set_dkeep, get_dkeep;
     1052static smallint set_standby, get_standby;
     1053static smallint set_lookahead, get_lookahead;
     1054static smallint set_prefetch, get_prefetch;
     1055static smallint set_defects, get_defects;
     1056static smallint set_wcache, get_wcache;
     1057static smallint set_doorlock, get_doorlock;
     1058static smallint set_seagate, get_seagate;
     1059static smallint set_standbynow, get_standbynow;
     1060static smallint set_sleepnow, get_sleepnow;
     1061static smallint get_powermode;
     1062static smallint set_apmmode, get_apmmode;
    11261063static int xfermode_requested;
    1127 static unsigned long set_lookahead, get_lookahead, lookahead;
    1128 static unsigned long set_prefetch, get_prefetch, prefetch;
    1129 static unsigned long set_defects, get_defects, defects;
    1130 static unsigned long set_wcache, get_wcache, wcache;
    1131 static unsigned long set_doorlock, get_doorlock, doorlock;
    1132 static unsigned long set_seagate, get_seagate;
    1133 static unsigned long set_standbynow, get_standbynow;
    1134 static unsigned long set_sleepnow, get_sleepnow;
    1135 static unsigned long get_powermode;
    1136 static unsigned long set_apmmode, get_apmmode, apmmode;
    1137 #endif
    1138 #ifdef CONFIG_FEATURE_HDPARM_GET_IDENTITY
    1139 static int get_IDentity;
    1140 #endif
    1141 #ifdef CONFIG_FEATURE_HDPARM_HDIO_UNREGISTER_HWIF
    1142 st