X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=coreutils%2Fdd.c;h=0c0ea07b95bc5bcc0c943c1a1962cc80a5fbc1d0;hb=2a17fbe88a0cc064248db4ce8939f0fbc357922d;hp=dac9ccdf3907fd06fc1d00902ea4922bdaeb2423;hpb=ed3ef50c233ffb1b50ea0e7382a8e60b86491009;p=oweals%2Fbusybox.git diff --git a/coreutils/dd.c b/coreutils/dd.c index dac9ccdf3..0c0ea07b9 100644 --- a/coreutils/dd.c +++ b/coreutils/dd.c @@ -3,156 +3,562 @@ * Mini dd implementation for busybox * * - * Copyright (C) 2000 by Matt Kraai - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Copyright (C) 2000,2001 Matt Kraai * + * Licensed under GPLv2 or later, see file LICENSE in this source tree. */ -#include "busybox.h" - -#include -#include -#include -#include -#include -#include - -static struct suffix_mult dd_suffixes[] = { - { "c", 1 }, - { "w", 2 }, - { "b", 512 }, - { "kD", 1000 }, - { "k", 1024 }, - { "MD", 1000000 }, - { "M", 1048576 }, - { "GD", 1000000000 }, - { "G", 1073741824 }, - { NULL, 0 } +//config:config DD +//config: bool "dd" +//config: default y +//config: help +//config: dd copies a file (from standard input to standard output, +//config: by default) using specific input and output blocksizes, +//config: while optionally performing conversions on it. +//config: +//config:config FEATURE_DD_SIGNAL_HANDLING +//config: bool "Enable signal handling for status reporting" +//config: default y +//config: depends on DD +//config: help +//config: Sending a SIGUSR1 signal to a running `dd' process makes it +//config: print to standard error the number of records read and written +//config: so far, then to resume copying. +//config: +//config: $ dd if=/dev/zero of=/dev/null & +//config: $ pid=$!; kill -USR1 $pid; sleep 1; kill $pid +//config: 10899206+0 records in +//config: 10899206+0 records out +//config: +//config:config FEATURE_DD_THIRD_STATUS_LINE +//config: bool "Enable the third status line upon signal" +//config: default y +//config: depends on DD && FEATURE_DD_SIGNAL_HANDLING +//config: help +//config: Displays a coreutils-like third status line with transferred bytes, +//config: elapsed time and speed. +//config: +//config:config FEATURE_DD_IBS_OBS +//config: bool "Enable ibs, obs and conv options" +//config: default y +//config: depends on DD +//config: help +//config: Enables support for writing a certain number of bytes in and out, +//config: at a time, and performing conversions on the data stream. +//config: +//config:config FEATURE_DD_STATUS +//config: bool "Enable status display options" +//config: default y +//config: depends on DD +//config: help +//config: Enables support for status=noxfer/none option. + +//usage:#define dd_trivial_usage +//usage: "[if=FILE] [of=FILE] " IF_FEATURE_DD_IBS_OBS("[ibs=N] [obs=N] ") "[bs=N] [count=N] [skip=N]\n" +//usage: " [seek=N]" IF_FEATURE_DD_IBS_OBS(" [conv=notrunc|noerror|sync|fsync] [iflag=skip_bytes]") +//usage:#define dd_full_usage "\n\n" +//usage: "Copy a file with converting and formatting\n" +//usage: "\n if=FILE Read from FILE instead of stdin" +//usage: "\n of=FILE Write to FILE instead of stdout" +//usage: "\n bs=N Read and write N bytes at a time" +//usage: IF_FEATURE_DD_IBS_OBS( +//usage: "\n ibs=N Read N bytes at a time" +//usage: ) +//usage: IF_FEATURE_DD_IBS_OBS( +//usage: "\n obs=N Write N bytes at a time" +//usage: ) +//usage: "\n count=N Copy only N input blocks" +//usage: "\n skip=N Skip N input blocks" +//usage: "\n seek=N Skip N output blocks" +//usage: IF_FEATURE_DD_IBS_OBS( +//usage: "\n conv=notrunc Don't truncate output file" +//usage: "\n conv=noerror Continue after read errors" +//usage: "\n conv=sync Pad blocks with zeros" +//usage: "\n conv=fsync Physically write data out before finishing" +//usage: "\n conv=swab Swap every pair of bytes" +//usage: "\n iflag=skip_bytes skip=N is in bytes" +//usage: ) +//usage: IF_FEATURE_DD_STATUS( +//usage: "\n status=noxfer Suppress rate output" +//usage: "\n status=none Suppress all output" +//usage: ) +//usage: "\n" +//usage: "\nN may be suffixed by c (1), w (2), b (512), kB (1000), k (1024), MB, M, GB, G" +//usage: +//usage:#define dd_example_usage +//usage: "$ dd if=/dev/zero of=/dev/ram1 bs=1M count=4\n" +//usage: "4+0 records in\n" +//usage: "4+0 records out\n" + +#include "libbb.h" + +/* This is a NOEXEC applet. Be very careful! */ + + +enum { + ifd = STDIN_FILENO, + ofd = STDOUT_FILENO, +}; + +struct globals { + off_t out_full, out_part, in_full, in_part; +#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE + unsigned long long total_bytes; + unsigned long long begin_time_us; +#endif + int flags; +} FIX_ALIASING; +#define G (*(struct globals*)&bb_common_bufsiz1) +#define INIT_G() do { \ + /* we have to zero it out because of NOEXEC */ \ + memset(&G, 0, sizeof(G)); \ +} while (0) + +enum { + /* Must be in the same order as OP_conv_XXX! */ + /* (see "flags |= (1 << what)" below) */ + FLAG_NOTRUNC = (1 << 0) * ENABLE_FEATURE_DD_IBS_OBS, + FLAG_SYNC = (1 << 1) * ENABLE_FEATURE_DD_IBS_OBS, + FLAG_NOERROR = (1 << 2) * ENABLE_FEATURE_DD_IBS_OBS, + FLAG_FSYNC = (1 << 3) * ENABLE_FEATURE_DD_IBS_OBS, + FLAG_SWAB = (1 << 4) * ENABLE_FEATURE_DD_IBS_OBS, + /* end of conv flags */ + /* start of input flags */ + FLAG_IFLAG_SHIFT = 5, + FLAG_SKIP_BYTES = (1 << 5) * ENABLE_FEATURE_DD_IBS_OBS, + /* end of input flags */ + FLAG_TWOBUFS = (1 << 6) * ENABLE_FEATURE_DD_IBS_OBS, + FLAG_COUNT = 1 << 7, + FLAG_STATUS = 1 << 8, + FLAG_STATUS_NONE = 1 << 9, + FLAG_STATUS_NOXFER = 1 << 10, }; -int dd_main(int argc, char **argv) +static void dd_output_status(int UNUSED_PARAM cur_signal) { - int i, ifd, ofd, oflag, sync = FALSE, trunc = TRUE; - size_t in_full = 0, in_part = 0, out_full = 0, out_part = 0; - size_t bs = 512, count = -1; - ssize_t n; - off_t seek = 0, skip = 0; - FILE *statusfp; - char *infile = NULL, *outfile = NULL, *buf; - - for (i = 1; i < argc; i++) { - if (strncmp("bs=", argv[i], 3) == 0) - bs = parse_number(argv[i]+3, dd_suffixes); - else if (strncmp("count=", argv[i], 6) == 0) - count = parse_number(argv[i]+6, dd_suffixes); - else if (strncmp("seek=", argv[i], 5) == 0) - seek = parse_number(argv[i]+5, dd_suffixes); - else if (strncmp("skip=", argv[i], 5) == 0) - skip = parse_number(argv[i]+5, dd_suffixes); - else if (strncmp("if=", argv[i], 3) == 0) - infile = argv[i]+3; - else if (strncmp("of=", argv[i], 3) == 0) - outfile = argv[i]+3; - else if (strncmp("conv=", argv[i], 5) == 0) { - buf = argv[i]+5; - while (1) { - if (strncmp("notrunc", buf, 7) == 0) { - trunc = FALSE; - buf += 7; - } else if (strncmp("sync", buf, 4) == 0) { - sync = TRUE; - buf += 4; - } else { - error_msg_and_die("invalid conversion `%s'\n", argv[i]+5); - } - if (buf[0] == '\0') - break; - if (buf[0] == ',') - buf++; - } - } else - usage(dd_usage); - } +#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE + double seconds; + unsigned long long bytes_sec; + unsigned long long now_us = monotonic_us(); /* before fprintf */ +#endif - buf = xmalloc(bs); + /* 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); - if (infile != NULL) { - if ((ifd = open(infile, O_RDONLY)) < 0) - perror_msg_and_die("%s", infile); - } else { - ifd = STDIN_FILENO; - infile = "standard input"; +#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE +# if ENABLE_FEATURE_DD_STATUS + if (G.flags & FLAG_STATUS_NOXFER) /* status=noxfer active? */ + return; + //TODO: should status=none make dd stop reacting to USR1 entirely? + //So far we react to it (we print the stats), + //status=none only suppresses final, non-USR1 generated status message. +# endif + fprintf(stderr, "%llu bytes (%sB) copied, ", + G.total_bytes, + /* show fractional digit, use suffixes */ + make_human_readable_str(G.total_bytes, 1, 0) + ); + /* Corner cases: + * ./busybox dd /dev/null + * ./busybox dd bs=1M count=2000 /dev/null + * (echo DONE) | ./busybox dd >/dev/null + * (sleep 1; echo DONE) | ./busybox dd >/dev/null + */ + seconds = (now_us - G.begin_time_us) / 1000000.0; + bytes_sec = G.total_bytes / seconds; + fprintf(stderr, "%f seconds, %sB/s\n", + seconds, + /* show fractional digit, use suffixes */ + make_human_readable_str(bytes_sec, 1, 0) + ); +#endif +} + +static ssize_t full_write_or_warn(const void *buf, size_t len, + const char *const filename) +{ + ssize_t n = full_write(ofd, buf, len); + if (n < 0) + bb_perror_msg("writing '%s'", filename); + return n; +} + +static bool write_and_stats(const void *buf, size_t len, size_t obs, + const char *filename) +{ + ssize_t n = full_write_or_warn(buf, len, filename); + if (n < 0) + return 1; + if ((size_t)n == obs) + G.out_full++; + else if (n) /* > 0 */ + G.out_part++; +#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE + G.total_bytes += n; +#endif + return 0; +} + +#if ENABLE_LFS +# define XATOU_SFX xatoull_sfx +#else +# define XATOU_SFX xatoul_sfx +#endif + +#if ENABLE_FEATURE_DD_IBS_OBS +static int parse_comma_flags(char *val, const char *words, const char *error_in) +{ + int flags = 0; + while (1) { + int n; + char *arg; + /* find ',', replace them with NUL so we can use val for + * index_in_strings() without copying. + * We rely on val being non-null, else strchr would fault. + */ + arg = strchr(val, ','); + if (arg) + *arg = '\0'; + n = index_in_strings(words, val); + if (n < 0) + bb_error_msg_and_die(bb_msg_invalid_arg_to, val, error_in); + flags |= (1 << n); + if (!arg) /* no ',' left, so this was the last specifier */ + break; + *arg = ','; /* to preserve ps listing */ + val = arg + 1; /* skip this keyword and ',' */ } + return flags; +} +#endif - if (outfile != NULL) { - oflag = O_WRONLY | O_CREAT; +int dd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int dd_main(int argc UNUSED_PARAM, char **argv) +{ + static const char keywords[] ALIGN1 = + "bs\0""count\0""seek\0""skip\0""if\0""of\0"IF_FEATURE_DD_STATUS("status\0") +#if ENABLE_FEATURE_DD_IBS_OBS + "ibs\0""obs\0""conv\0""iflag\0" +#endif + ; +#if ENABLE_FEATURE_DD_IBS_OBS + static const char conv_words[] ALIGN1 = + "notrunc\0""sync\0""noerror\0""fsync\0""swab\0"; + static const char iflag_words[] ALIGN1 = + "skip_bytes\0"; +#endif +#if ENABLE_FEATURE_DD_STATUS + static const char status_words[] ALIGN1 = + "none\0""noxfer\0"; +#endif + enum { + OP_bs = 0, + OP_count, + OP_seek, + OP_skip, + OP_if, + OP_of, + IF_FEATURE_DD_STATUS(OP_status,) +#if ENABLE_FEATURE_DD_IBS_OBS + OP_ibs, + OP_obs, + OP_conv, + OP_iflag, + /* Must be in the same order as FLAG_XXX! */ + OP_conv_notrunc = 0, + OP_conv_sync, + OP_conv_noerror, + OP_conv_fsync, + OP_conv_swab, + /* Unimplemented conv=XXX: */ + //nocreat do not create the output file + //excl fail if the output file already exists + //fdatasync physically write output file data before finishing + //lcase change upper case to lower case + //ucase change lower case to upper case + //block pad newline-terminated records with spaces to cbs-size + //unblock replace trailing spaces in cbs-size records with newline + //ascii from EBCDIC to ASCII + //ebcdic from ASCII to EBCDIC + //ibm from ASCII to alternate EBCDIC + /* Partially implemented: */ + //swab swap every pair of input bytes: will abort on non-even reads + OP_iflag_skip_bytes, +#endif + }; + smallint exitcode = EXIT_FAILURE; + int i; + size_t ibs = 512; + char *ibuf; +#if ENABLE_FEATURE_DD_IBS_OBS + size_t obs = 512; + char *obuf; +#else +# define obs ibs +# define obuf ibuf +#endif + /* These are all zeroed at once! */ + struct { + size_t oc; + ssize_t prev_read_size; /* for detecting swab failure */ + off_t count; + off_t seek, skip; + const char *infile, *outfile; + } Z; +#define oc (Z.oc ) +#define prev_read_size (Z.prev_read_size) +#define count (Z.count ) +#define seek (Z.seek ) +#define skip (Z.skip ) +#define infile (Z.infile ) +#define outfile (Z.outfile) - if (!seek && trunc) - oflag |= O_TRUNC; + memset(&Z, 0, sizeof(Z)); + INIT_G(); + //fflush_all(); - is this needed because of NOEXEC? - if ((ofd = open(outfile, oflag, 0666)) < 0) - perror_msg_and_die("%s", outfile); + for (i = 1; argv[i]; i++) { + int what; + char *val; + char *arg = argv[i]; - if (seek && trunc) { - if (ftruncate(ofd, seek * bs) < 0) - perror_msg_and_die("%s", outfile); +#if ENABLE_DESKTOP + /* "dd --". NB: coreutils 6.9 will complain if they see + * more than one of them. We wouldn't. */ + if (arg[0] == '-' && arg[1] == '-' && arg[2] == '\0') + continue; +#endif + val = strchr(arg, '='); + if (val == NULL) + bb_show_usage(); + *val = '\0'; + what = index_in_strings(keywords, arg); + if (what < 0) + bb_show_usage(); + /* *val = '='; - to preserve ps listing? */ + val++; +#if ENABLE_FEATURE_DD_IBS_OBS + if (what == OP_ibs) { + /* Must fit into positive ssize_t */ + ibs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, cwbkMG_suffixes); + /*continue;*/ + } + if (what == OP_obs) { + obs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, cwbkMG_suffixes); + /*continue;*/ + } + if (what == OP_conv) { + G.flags |= parse_comma_flags(val, conv_words, "conv"); + /*continue;*/ + } + if (what == OP_iflag) { + G.flags |= parse_comma_flags(val, iflag_words, "iflag") << FLAG_IFLAG_SHIFT; + /*continue;*/ + } +#endif + if (what == OP_bs) { + ibs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, cwbkMG_suffixes); + obs = ibs; + /*continue;*/ + } + /* These can be large: */ + if (what == OP_count) { + G.flags |= FLAG_COUNT; + count = XATOU_SFX(val, cwbkMG_suffixes); + /*continue;*/ + } + if (what == OP_seek) { + seek = XATOU_SFX(val, cwbkMG_suffixes); + /*continue;*/ + } + if (what == OP_skip) { + skip = XATOU_SFX(val, cwbkMG_suffixes); + /*continue;*/ + } + if (what == OP_if) { + infile = val; + /*continue;*/ + } + if (what == OP_of) { + outfile = val; + /*continue;*/ } +#if ENABLE_FEATURE_DD_STATUS + if (what == OP_status) { + int n; + n = index_in_strings(status_words, val); + if (n < 0) + bb_error_msg_and_die(bb_msg_invalid_arg_to, val, "status"); + G.flags |= FLAG_STATUS << n; + /*continue;*/ + } +#endif + } /* end of "for (argv[i])" */ + +//XXX:FIXME for huge ibs or obs, malloc'ing them isn't the brightest idea ever + ibuf = xmalloc(ibs); + obuf = ibuf; +#if ENABLE_FEATURE_DD_IBS_OBS + if (ibs != obs) { + G.flags |= FLAG_TWOBUFS; + obuf = xmalloc(obs); + } +#endif - statusfp = stdout; +#if ENABLE_FEATURE_DD_SIGNAL_HANDLING + signal_SA_RESTART_empty_mask(SIGUSR1, dd_output_status); +#endif +#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE + G.begin_time_us = monotonic_us(); +#endif + + if (infile) { + xmove_fd(xopen(infile, O_RDONLY), ifd); } else { - ofd = STDOUT_FILENO; - outfile = "standard output"; - statusfp = stderr; + infile = bb_msg_standard_input; } + if (outfile) { + int oflag = O_WRONLY | O_CREAT; + + if (!seek && !(G.flags & FLAG_NOTRUNC)) + oflag |= O_TRUNC; + + xmove_fd(xopen(outfile, oflag), ofd); + + if (seek && !(G.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) + ) { + goto die_outfile; + } + } + } + } else { + outfile = bb_msg_standard_output; + } if (skip) { - if (lseek(ifd, skip * bs, SEEK_CUR) < 0) - perror_msg_and_die("%s", infile); + size_t blocksz = (G.flags & FLAG_SKIP_BYTES) ? 1 : ibs; + if (lseek(ifd, skip * blocksz, SEEK_CUR) < 0) { + do { + ssize_t n = safe_read(ifd, ibuf, blocksz); + if (n < 0) + goto die_infile; + if (n == 0) + break; + } while (--skip != 0); + } } - if (seek) { - if (lseek(ofd, seek * bs, SEEK_CUR) < 0) - perror_msg_and_die("%s", outfile); + if (lseek(ofd, seek * obs, SEEK_CUR) < 0) + goto die_outfile; } - while (in_full + in_part != count) { - n = safe_read(ifd, buf, bs); - if (n < 0) - perror_msg_and_die("%s", infile); + while (!(G.flags & FLAG_COUNT) || (G.in_full + G.in_part != count)) { + ssize_t n; + + n = safe_read(ifd, ibuf, ibs); if (n == 0) break; - if (n == bs) - in_full++; - else - in_part++; - if (sync) { - memset(buf + n, '\0', bs - n); - n = bs; - } - n = full_write(ofd, buf, n); - if (n < 0) - perror_msg_and_die("%s", outfile); - if (n == bs) - out_full++; - else - out_part++; + if (n < 0) { + /* "Bad block" */ + if (!(G.flags & FLAG_NOERROR)) + goto die_infile; + bb_simple_perror_msg(infile); + /* GNU dd with conv=noerror skips over bad blocks */ + xlseek(ifd, ibs, SEEK_CUR); + /* conv=noerror,sync writes NULs, + * conv=noerror just ignores input bad blocks */ + n = 0; + } + if (G.flags & FLAG_SWAB) { + uint16_t *p16; + ssize_t n2; + + /* Our code allows only last read to be odd-sized */ + if (prev_read_size & 1) + bb_error_msg_and_die("can't swab %lu byte buffer", + (unsigned long)prev_read_size); + prev_read_size = n; + + /* If n is odd, last byte is not swapped: + * echo -n "qwe" | dd conv=swab + * prints "wqe". + */ + p16 = (void*) ibuf; + n2 = (n >> 1); + while (--n2 >= 0) { + *p16 = bswap_16(*p16); + p16++; + } + } + if ((size_t)n == ibs) + G.in_full++; + else { + G.in_part++; + if (G.flags & FLAG_SYNC) { + memset(ibuf + n, 0, ibs - n); + n = ibs; + } + } + if (G.flags & FLAG_TWOBUFS) { + char *tmp = ibuf; + while (n) { + size_t d = obs - oc; + + if (d > (size_t)n) + d = n; + memcpy(obuf + oc, tmp, d); + n -= d; + tmp += d; + oc += d; + if (oc == obs) { + if (write_and_stats(obuf, obs, obs, outfile)) + goto out_status; + oc = 0; + } + } + } else { + if (write_and_stats(ibuf, n, obs, outfile)) + goto out_status; + } + + if (G.flags & FLAG_FSYNC) { + if (fsync(ofd) < 0) + goto die_outfile; + } + } + + if (ENABLE_FEATURE_DD_IBS_OBS && oc) { + if (write_and_stats(obuf, oc, obs, outfile)) + goto out_status; + } + if (close(ifd) < 0) { + die_infile: + bb_simple_perror_msg_and_die(infile); } - fprintf(statusfp, "%d+%d records in\n", in_full, in_part); - fprintf(statusfp, "%d+%d records out\n", out_full, out_part); + if (close(ofd) < 0) { + die_outfile: + bb_simple_perror_msg_and_die(outfile); + } + + exitcode = EXIT_SUCCESS; + out_status: + if (!ENABLE_FEATURE_DD_STATUS || !(G.flags & FLAG_STATUS_NONE)) + dd_output_status(0); + + if (ENABLE_FEATURE_CLEAN_UP) { + free(obuf); + if (G.flags & FLAG_TWOBUFS) + free(ibuf); + } - return EXIT_SUCCESS; + return exitcode; }