Changeset 1765 in MondoRescue for branches/2.2.5/mindi-busybox/coreutils/dd.c

Timestamp:

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

Author:

Bruno Cornec

Message:

Update to busybox 1.7.2

File:

• branches/2.2.5/mindi-busybox/coreutils/dd.c (modified) (6 diffs)

branches/2.2.5/mindi-busybox/coreutils/dd.c

@@ -9 +9 @@
  */
 
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-#include <fcntl.h>
-#include <signal.h>  // For FEATURE_DD_SIGNAL_HANDLING
-#include "busybox.h"
+#include <signal.h>  /* For FEATURE_DD_SIGNAL_HANDLING */
+#include "libbb.h"
+
+/* This is a NOEXEC applet. Be very careful! */
+
 
 static const struct suffix_mult dd_suffixes[] = {
@@ -25 +21 @@
     { "kD", 1000 },
     { "k", 1024 },
+    { "K", 1024 },  /* compat with coreutils dd */
     { "MD", 1000000 },
     { "M", 1048576 },
     { "GD", 1000000000 },
     { "G", 1073741824 },
-    { NULL, 0 }
+    { }
 };
 
-static size_t out_full;
-static size_t out_part;
-static size_t in_full;
-static size_t in_part;
-
-static void dd_output_status(int cur_signal)
+struct globals {
+    off_t out_full, out_part, in_full, in_part;
+};
+#define G (*(struct globals*)&bb_common_bufsiz1)
+/* We have to zero it out because of NOEXEC */
+#define INIT_G() memset(&G, 0, sizeof(G))
+
+
+static void dd_output_status(int ATTRIBUTE_UNUSED cur_signal)
 {
-    fprintf(stderr, "%ld+%ld records in\n%ld+%ld records out\n",
-            (long)in_full, (long)in_part,
-            (long)out_full, (long)out_part);
+    /* Deliberately using %u, not %d */
+    fprintf(stderr, "%"OFF_FMT"u+%"OFF_FMT"u records in\n"
+            "%"OFF_FMT"u+%"OFF_FMT"u records out\n",
+            G.in_full, G.in_part,
+            G.out_full, G.out_part);
 }
 
+static ssize_t full_write_or_warn(int fd, const void *buf, size_t len,
+    const char *const filename)
+{
+    ssize_t n = full_write(fd, buf, len);
+    if (n < 0)
+        bb_perror_msg("writing '%s'", filename);
+    return n;
+}
+
+static bool write_and_stats(int fd, const void *buf, size_t len, size_t obs,
+    const char *filename)
+{
+    ssize_t n = full_write_or_warn(fd, buf, len, filename);
+    if (n < 0)
+        return 1;
+    if (n == obs)
+        G.out_full++;
+    else if (n) /* > 0 */
+        G.out_part++;
+    return 0;
+}
+
+#if ENABLE_LFS
+#define XATOU_SFX xatoull_sfx
+#else
+#define XATOU_SFX xatoul_sfx
+#endif
+
+int dd_main(int argc, char **argv);
 int dd_main(int argc, char **argv)
 {
-    size_t count = -1, oc = 0, ibs = 512, obs = 512;
-    ssize_t n;
-    off_t seek = 0, skip = 0;
-    int sync_flag = FALSE, noerror = FALSE, trunc_flag = TRUE, twobufs_flag = 0,
-        oflag, ifd, ofd, i;
-    const char *infile = NULL, *outfile = NULL;
+    enum {
+        FLAG_SYNC    = 1 << 0,
+        FLAG_NOERROR = 1 << 1,
+        FLAG_NOTRUNC = 1 << 2,
+        FLAG_TWOBUFS = 1 << 3,
+        FLAG_COUNT   = 1 << 4,
+    };
+    static const char keywords[] ALIGN1 =
+        "bs=\0""count=\0""seek=\0""skip=\0""if=\0""of=\0"
+#if ENABLE_FEATURE_DD_IBS_OBS
+        "ibs=\0""obs=\0""conv=\0""notrunc\0""sync\0""noerror\0"
+#endif
+        ;
+    enum {
+        OP_bs = 1,
+        OP_count,
+        OP_seek,
+        OP_skip,
+        OP_if,
+        OP_of,
+#if ENABLE_FEATURE_DD_IBS_OBS
+        OP_ibs,
+        OP_obs,
+        OP_conv,
+        OP_conv_notrunc,
+        OP_conv_sync,
+        OP_conv_noerror,
+#endif
+    };
+    size_t ibs = 512, obs = 512;
+    ssize_t n, w;
     char *ibuf, *obuf;
-
-    if (ENABLE_FEATURE_DD_SIGNAL_HANDLING)
-    {
-        struct sigaction sa;
-
-        memset(&sa, 0, sizeof(sa));
-        sa.sa_handler = dd_output_status; 
-        sa.sa_flags = SA_RESTART;
-        sigemptyset(&sa.sa_mask);
-        sigaction(SIGUSR1, &sa, 0); 
-    }
-
-    for (i = 1; i < argc; i++) {
-        if (ENABLE_FEATURE_DD_IBS_OBS && !strncmp("ibs=", argv[i], 4)) {
-            ibs = bb_xparse_number(argv[i]+4, dd_suffixes);
-            twobufs_flag++;
-        } else if (ENABLE_FEATURE_DD_IBS_OBS && !strncmp("obs=", argv[i], 4)) {
-            obs = bb_xparse_number(argv[i]+4, dd_suffixes);
-            twobufs_flag++;
-        } else if (!strncmp("bs=", argv[i], 3)) {
-            ibs = obs = bb_xparse_number(argv[i]+3, dd_suffixes);
-        } else if (!strncmp("count=", argv[i], 6))
-            count = bb_xparse_number(argv[i]+6, dd_suffixes);
-        else if (!strncmp("seek=", argv[i], 5))
-            seek = bb_xparse_number(argv[i]+5, dd_suffixes);
-        else if (!strncmp("skip=", argv[i], 5))
-            skip = bb_xparse_number(argv[i]+5, dd_suffixes);
-        else if (!strncmp("if=", argv[i], 3))
-            infile = argv[i]+3;
-        else if (!strncmp("of=", argv[i], 3))
-            outfile = argv[i]+3;
-        else if (ENABLE_FEATURE_DD_IBS_OBS && !strncmp("conv=", argv[i], 5)) {
-            ibuf = argv[i]+5;
-            while (1) {
-                if (!strncmp("notrunc", ibuf, 7)) {
-                    trunc_flag = FALSE;
-                    ibuf += 7;
-                } else if (!strncmp("sync", ibuf, 4)) {
-                    sync_flag = TRUE;
-                    ibuf += 4;
-                } else if (!strncmp("noerror", ibuf, 7)) {
-                    noerror = TRUE;
-                    ibuf += 7;
-                } else {
-                    bb_error_msg_and_die(bb_msg_invalid_arg, argv[i]+5, "conv");
+    /* And these are all zeroed at once! */
+    struct {
+        int flags;
+        int ifd, ofd;
+        size_t oc;
+        off_t count;
+        off_t seek, skip;
+        const char *infile, *outfile;
+#if ENABLE_FEATURE_DD_SIGNAL_HANDLING
+        struct sigaction sigact;
+#endif
+    } Z;
+#define flags   (Z.flags  )
+#define ifd     (Z.ifd    )
+#define ofd     (Z.ofd    )
+#define oc      (Z.oc     )
+#define count   (Z.count  )
+#define seek    (Z.seek   )
+#define skip    (Z.skip   )
+#define infile  (Z.infile )
+#define outfile (Z.outfile)
+#define sigact  (Z.sigact )
+
+    memset(&Z, 0, sizeof(Z));
+    INIT_G();
+
+#if ENABLE_FEATURE_DD_SIGNAL_HANDLING
+    sigact.sa_handler = dd_output_status;
+    sigact.sa_flags = SA_RESTART;
+    sigemptyset(&sigact.sa_mask);
+    sigaction(SIGUSR1, &sigact, NULL);
+#endif
+
+    for (n = 1; n < argc; n++) {
+        smalluint key_len;
+        smalluint what;
+        char *key;
+        char *arg = argv[n];
+
+//XXX:FIXME: we reject plain "dd --" This would cost ~20 bytes, so..
+//if (*arg == '-' && *++arg == '-' && !*++arg) continue;
+        key = strstr(arg, "=");
+        if (key == NULL)
+            bb_show_usage();
+        key_len = key - arg + 1;
+        key = xstrndup(arg, key_len);
+        what = index_in_strings(keywords, key) + 1;
+        if (ENABLE_FEATURE_CLEAN_UP)
+            free(key);
+        if (what == 0)
+            bb_show_usage();
+        arg += key_len;
+        /* Must fit into positive ssize_t */
+#if ENABLE_FEATURE_DD_IBS_OBS
+            if (what == OP_ibs) {
+                ibs = xatoul_range_sfx(arg, 1, ((size_t)-1L)/2, dd_suffixes);
+                continue;
+            }
+            if (what == OP_obs) {
+                obs = xatoul_range_sfx(arg, 1, ((size_t)-1L)/2, dd_suffixes);
+                continue;
+            }
+            if (what == OP_conv) {
+                while (1) {
+                    /* find ',', replace them with nil so we can use arg for
+                     * index_in_strings() without copying.
+                     * We rely on arg being non-null, else strchr would fault.
+                     */
+                    key = strchr(arg, ',');
+                    if (key)
+                        *key = '\0';
+                    what = index_in_strings(keywords, arg) + 1;
+                    if (what < OP_conv_notrunc)
+                        bb_error_msg_and_die(bb_msg_invalid_arg, arg, "conv");
+                    if (what == OP_conv_notrunc)
+                        flags |= FLAG_NOTRUNC;
+                    if (what == OP_conv_sync)
+                        flags |= FLAG_SYNC;
+                    if (what == OP_conv_noerror)
+                        flags |= FLAG_NOERROR;
+                    if (!key) /* no ',' left, so this was the last specifier */
+                        break;
+                    arg = key + 1; /* skip this keyword and ',' */
                 }
-                if (ibuf[0] == '\0') break;
-                if (ibuf[0] == ',') ibuf++;
-            }
-        } else
-            bb_show_usage();
-    }
-    ibuf = xmalloc(ibs);
-
-    if (twobufs_flag) obuf = xmalloc(obs);
-    else obuf = ibuf;
-
-    if (infile != NULL) {
-        ifd = bb_xopen(infile, O_RDONLY);
-    } else {
-        ifd = STDIN_FILENO;
+                continue;
+            }
+#endif
+        if (what == OP_bs) {
+            ibs = obs = xatoul_range_sfx(arg, 1, ((size_t)-1L)/2, dd_suffixes);
+            continue;
+        }
+        /* These can be large: */
+        if (what == OP_count) {
+            flags |= FLAG_COUNT;
+            count = XATOU_SFX(arg, dd_suffixes);
+            continue;
+        }
+        if (what == OP_seek) {
+            seek = XATOU_SFX(arg, dd_suffixes);
+            continue;
+        }
+        if (what == OP_skip) {
+            skip = XATOU_SFX(arg, dd_suffixes);
+            continue;
+        }
+        if (what == OP_if) {
+            infile = arg;
+            continue;
+        }
+        if (what == OP_of)
+            outfile = arg;
+    }
+//XXX:FIXME for huge ibs or obs, malloc'ing them isn't the brightest idea ever
+    ibuf = obuf = xmalloc(ibs);
+    if (ibs != obs) {
+        flags |= FLAG_TWOBUFS;
+        obuf = xmalloc(obs);
+    }
+    if (infile != NULL)
+        ifd = xopen(infile, O_RDONLY);
+    else {
+        /* ifd = STDIN_FILENO; - it's zero and it's already there */
         infile = bb_msg_standard_input;
     }
-
     if (outfile != NULL) {
-        oflag = O_WRONLY | O_CREAT;
-
-        if (!seek && trunc_flag) {
+        int oflag = O_WRONLY | O_CREAT;
+
+        if (!seek && !(flags & FLAG_NOTRUNC))
             oflag |= O_TRUNC;
-        }
-
-        ofd = bb_xopen3(outfile, oflag, 0666);
-
-        if (seek && trunc_flag) {
+
+        ofd = xopen(outfile, oflag);
+
+        if (seek && !(flags & FLAG_NOTRUNC)) {
             if (ftruncate(ofd, seek * obs) < 0) {
                 struct stat st;
 
-                if (fstat (ofd, &st) < 0 || S_ISREG (st.st_mode) ||
-                        S_ISDIR (st.st_mode)) {
-                    bb_perror_msg_and_die("%s", outfile);
-                }
+                if (fstat(ofd, &st) < 0 || S_ISREG(st.st_mode) ||
+                        S_ISDIR(st.st_mode))
+                    goto die_outfile;
             }
         }
@@ -140 +254 @@
         outfile = bb_msg_standard_output;
     }
-
     if (skip) {
         if (lseek(ifd, skip * ibs, SEEK_CUR) < 0) {
@@ -146 +259 @@
                 n = safe_read(ifd, ibuf, ibs);
                 if (n < 0)
-                    bb_perror_msg_and_die("%s", infile);
+                    goto die_infile;
                 if (n == 0)
                     break;
@@ -152 +265 @@
         }
     }
-
     if (seek) {
-        if (lseek(ofd, seek * obs, SEEK_CUR) < 0) {
-            bb_perror_msg_and_die("%s", outfile);
-        }
-    }
-
-    while (in_full + in_part != count) {
-        if (noerror) {
-            /* Pre-zero the buffer when doing the noerror thing */
-            memset(ibuf, '\0', ibs);
-        }
-
+        if (lseek(ofd, seek * obs, SEEK_CUR) < 0)
+            goto die_outfile;
+    }
+
+    while (!(flags & FLAG_COUNT) || (G.in_full + G.in_part != count)) {
+        if (flags & FLAG_NOERROR) /* Pre-zero the buffer if conv=noerror */
+            memset(ibuf, 0, ibs);
         n = safe_read(ifd, ibuf, ibs);
-        if (n == 0) {
+        if (n == 0)
             break;
-        }
         if (n < 0) {
-            if (noerror) {
+            if (flags & FLAG_NOERROR) {
                 n = ibs;
                 bb_perror_msg("%s", infile);
-            } else {
-                bb_perror_msg_and_die("%s", infile);
-            }
-        }
-        if ((size_t)n == ibs) {
-            in_full++;
-        } else {
-            in_part++;
-            if (sync_flag) {
+            } else
+                goto die_infile;
+        }
+        if ((size_t)n == ibs)
+            G.in_full++;
+        else {
+            G.in_part++;
+            if (flags & FLAG_SYNC) {
                 memset(ibuf + n, '\0', ibs - n);
                 n = ibs;
             }
         }
-        if (twobufs_flag) {
+        if (flags & FLAG_TWOBUFS) {
             char *tmp = ibuf;
             while (n) {
                 size_t d = obs - oc;
 
-                if (d > n) d = n;
+                if (d > n)
+                    d = n;
                 memcpy(obuf + oc, tmp, d);
                 n -= d;
@@ -197 +304 @@
                 oc += d;
                 if (oc == obs) {
-                    if (bb_full_write(ofd, obuf, obs) < 0) {
-                        bb_perror_msg_and_die("%s", outfile);
-                    }
-                    out_full++;
+                    if (write_and_stats(ofd, obuf, obs, obs, outfile))
+                        goto out_status;
                     oc = 0;
                 }
             }
-        } else {
-            if ((n = bb_full_write(ofd, ibuf, n)) < 0) {
-                bb_perror_msg_and_die("%s", outfile);
-            }
-            if (n == ibs) out_full++;
-            else out_part++;
-        }
-    }
-    
+        } else if (write_and_stats(ofd, ibuf, n, obs, outfile))
+            goto out_status;
+    }
+
     if (ENABLE_FEATURE_DD_IBS_OBS && oc) {
-        if (bb_full_write(ofd, obuf, oc) < 0) {
-            bb_perror_msg_and_die("%s", outfile);
-        }
-        out_part++;
-    }
-    if (close (ifd) < 0) {
+        w = full_write_or_warn(ofd, obuf, oc, outfile);
+        if (w < 0) goto out_status;
+        if (w > 0)
+            G.out_part++;
+    }
+    if (close(ifd) < 0) {
+ die_infile:
         bb_perror_msg_and_die("%s", infile);
     }
 
-    if (close (ofd) < 0) {
+    if (close(ofd) < 0) {
+ die_outfile:
         bb_perror_msg_and_die("%s", outfile);
     }
-
+ out_status:
     dd_output_status(0);