X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=coreutils%2Fdd.c;h=347a19454ecd9cf3a1dd1a70c10586c1e65de695;hb=8d0e0cdadf726beab28ccdc7d69738c1534e1f74;hp=a2dc1c396917e5f8e94cdc793c51e686c3e4bef6;hpb=cb41c2e83b9e9997b9737d7061d53f7c11a463a8;p=oweals%2Fbusybox.git diff --git a/coreutils/dd.c b/coreutils/dd.c index a2dc1c396..347a19454 100644 --- a/coreutils/dd.c +++ b/coreutils/dd.c @@ -1,234 +1,401 @@ +/* vi: set sw=4 ts=4: */ /* * Mini dd implementation for busybox * - * Copyright (C) 1999 by Lineo, inc. - * Written by Erik Andersen , - * based in part on code taken from sash. * - * Copyright (c) 1999 by David I. Bell - * Permission is granted to use, distribute, or modify this source, - * provided that this copyright notice remains intact. - * - * Permission to distribute this code under the GPL has been granted. - * - * 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 "internal.h" -#include -#include -#include -#include -#if (__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1) -#include -#else -typedef unsigned long long int uintmax_t; +#include "libbb.h" + +/* This is a NOEXEC applet. Be very careful! */ + + +enum { + ifd = STDIN_FILENO, + ofd = STDOUT_FILENO, +}; + +static const struct suffix_mult dd_suffixes[] = { + { "c", 1 }, + { "w", 2 }, + { "b", 512 }, + { "kD", 1000 }, + { "k", 1024 }, + { "K", 1024 }, /* compat with coreutils dd */ + { "MD", 1000000 }, + { "M", 1048576 }, + { "GD", 1000000000 }, + { "G", 1073741824 }, + { "", 0 } +}; + +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 +} 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) -static const char dd_usage[] = -"dd [if=name] [of=name] [bs=n] [count=n]\n\n" -"Copy a file, converting and formatting according to options\n\n" -"\tif=FILE\tread from FILE instead of stdin\n" -"\tof=FILE\twrite to FILE instead of stout\n" -"\tbs=n\tread and write N BYTES at a time\n" -"\tcount=n\tcopy only n input blocks\n" -//"\tskip=n\tskip n input blocks\n" -"\n" -"BYTES may be suffixed: by k for x1024, b for x512, and w for x2.\n"; - - - -/* - * Read a number with a possible multiplier. - * Returns -1 if the number format is illegal. - */ -static long getNum (const char *cp) +static void dd_output_status(int UNUSED_PARAM cur_signal) { - long value; - - if (!isDecimal (*cp)) - return -1; - - value = 0; - - while (isDecimal (*cp)) - value = value * 10 + *cp++ - '0'; - - switch (*cp++) { - case 'k': - value *= 1024; - break; - - case 'b': - value *= 512; - break; - - case 'w': - value *= 2; - break; - - case '\0': - return value; +#if ENABLE_FEATURE_DD_THIRD_STATUS_LINE + double seconds; + unsigned long long bytes_sec; + unsigned long long now_us = monotonic_us(); /* before fprintf */ +#endif - default: - return -1; - } + /* 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 ENABLE_FEATURE_DD_THIRD_STATUS_LINE + 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 +} - if (*cp) - return -1; +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; +} - return value; +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 -extern int dd_main (int argc, char **argv) +int dd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; +int dd_main(int argc UNUSED_PARAM, char **argv) { - const char *inFile = NULL; - const char *outFile = NULL; - char *cp; - int inFd; - int outFd; - int inCc = 0; - int outCc; - size_t blockSize = 512; - //uintmax_t skipBlocks = 0; - uintmax_t count = (uintmax_t)-1; - uintmax_t intotal; - uintmax_t outTotal; - unsigned char *buf; - - argc--; - argv++; - - /* Parse any options */ - while (argc) { - if (inFile == NULL && (strncmp(*argv, "if", 2) == 0)) - inFile=((strchr(*argv, '='))+1); - else if (outFile == NULL && (strncmp(*argv, "of", 2) == 0)) - outFile=((strchr(*argv, '='))+1); - else if (strncmp("count", *argv, 5) == 0) { - count = getNum ((strchr(*argv, '='))+1); - if (count <= 0) { - fprintf (stderr, "Bad count value %s\n", *argv); - goto usage; - } - } - else if (strncmp(*argv, "bs", 2) == 0) { - blockSize = getNum ((strchr(*argv, '='))+1); - if (blockSize <= 0) { - fprintf (stderr, "Bad block size value %s\n", *argv); - goto usage; - } + enum { + /* Must be in the same order as OP_conv_XXX! */ + /* (see "flags |= (1 << what)" below) */ + FLAG_NOTRUNC = 1 << 0, + FLAG_SYNC = 1 << 1, + FLAG_NOERROR = 1 << 2, + FLAG_FSYNC = 1 << 3, + /* end of conv flags */ + FLAG_TWOBUFS = 1 << 4, + FLAG_COUNT = 1 << 5, + }; + 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" +#endif + ; +#if ENABLE_FEATURE_DD_IBS_OBS + static const char conv_words[] ALIGN1 = + "notrunc\0""sync\0""noerror\0""fsync\0"; +#endif + enum { + OP_bs = 0, + OP_count, + OP_seek, + OP_skip, + OP_if, + OP_of, +#if ENABLE_FEATURE_DD_IBS_OBS + OP_ibs, + OP_obs, + OP_conv, + /* Must be in the same order as FLAG_XXX! */ + OP_conv_notrunc = 0, + OP_conv_sync, + OP_conv_noerror, + OP_conv_fsync, + /* 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 + //swab swap every pair of input bytes + //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 +#endif + }; + int exitcode = EXIT_FAILURE; + size_t ibs = 512, obs = 512; + ssize_t n, w; + char *ibuf, *obuf; + /* And these are all zeroed at once! */ + struct { + int flags; + size_t oc; + off_t count; + off_t seek, skip; + const char *infile, *outfile; + } Z; +#define flags (Z.flags ) +#define oc (Z.oc ) +#define count (Z.count ) +#define seek (Z.seek ) +#define skip (Z.skip ) +#define infile (Z.infile ) +#define outfile (Z.outfile) + + memset(&Z, 0, sizeof(Z)); + INIT_G(); + //fflush_all(); - is this needed because of NOEXEC? + + for (n = 1; argv[n]; n++) { + int what; + char *val; + char *arg = argv[n]; + +#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, dd_suffixes); + /*continue;*/ + } + if (what == OP_obs) { + obs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, dd_suffixes); + /*continue;*/ + } + if (what == OP_conv) { + while (1) { + /* 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'; + what = index_in_strings(conv_words, val); + if (what < 0) + bb_error_msg_and_die(bb_msg_invalid_arg, val, "conv"); + flags |= (1 << what); + if (!arg) /* no ',' left, so this was the last specifier */ + break; + /* *arg = ','; - to preserve ps listing? */ + val = arg + 1; /* skip this keyword and ',' */ + } + continue; /* we trashed 'what', can't fall through */ + } +#endif + if (what == OP_bs) { + ibs = obs = xatoul_range_sfx(val, 1, ((size_t)-1L)/2, dd_suffixes); + /*continue;*/ + } + /* These can be large: */ + if (what == OP_count) { + flags |= FLAG_COUNT; + count = XATOU_SFX(val, dd_suffixes); + /*continue;*/ + } + if (what == OP_seek) { + seek = XATOU_SFX(val, dd_suffixes); + /*continue;*/ + } + if (what == OP_skip) { + skip = XATOU_SFX(val, dd_suffixes); + /*continue;*/ + } + if (what == OP_if) { + infile = val; + /*continue;*/ + } + if (what == OP_of) { + outfile = val; + /*continue;*/ + } + } /* end of "for (argv[n])" */ + +//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 0 - else if (strncmp(*argv, "skip", 4) == 0) { - skipBlocks = atoi( *argv); - if (skipBlocks <= 0) { - fprintf (stderr, "Bad skip value %d\n", skipBlocks); - goto usage; - } - } +#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 != NULL) + xmove_fd(xopen(infile, O_RDONLY), ifd); else { - goto usage; + infile = bb_msg_standard_input; } - argc--; - argv++; - } - - buf = malloc (blockSize); - if (buf == NULL) { - fprintf (stderr, "Cannot allocate buffer\n"); - exit( FALSE); - } - - intotal = 0; - outTotal = 0; - - if (inFile == NULL) - inFd = fileno(stdin); - else - inFd = open (inFile, 0); - - if (inFd < 0) { - perror (inFile); - free (buf); - exit( FALSE); - } - - if (outFile == NULL) - outFd = fileno(stdout); - else - outFd = creat (outFile, 0666); - - if (outFd < 0) { - perror (outFile); - close (inFd); - free (buf); - exit( FALSE); - } - - //lseek(inFd, skipBlocks*blockSize, SEEK_SET); - while (outTotal < count * blockSize) { - inCc = read (inFd, buf, blockSize); - if (inCc < 0) { - perror (inFile); - goto cleanup; - } else if (inCc == 0) { - goto cleanup; + if (outfile != NULL) { + int oflag = O_WRONLY | O_CREAT; + + if (!seek && !(flags & FLAG_NOTRUNC)) + oflag |= O_TRUNC; + + xmove_fd(xopen(outfile, oflag), ofd); + + 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) + ) { + goto die_outfile; + } + } + } + } else { + outfile = bb_msg_standard_output; } - intotal += inCc; - cp = buf; - - while (intotal > outTotal) { - if (outTotal + inCc > count * blockSize) - inCc = count * blockSize - outTotal; - outCc = write (outFd, cp, inCc); - if (outCc < 0) { - perror (outFile); - goto cleanup; - } else if (outCc == 0) { - goto cleanup; - } - - inCc -= outCc; - cp += outCc; - outTotal += outCc; + if (skip) { + if (lseek(ifd, skip * ibs, SEEK_CUR) < 0) { + while (skip-- > 0) { + n = safe_read(ifd, ibuf, ibs); + if (n < 0) + goto die_infile; + if (n == 0) + break; + } + } + } + if (seek) { + if (lseek(ofd, seek * obs, SEEK_CUR) < 0) + goto die_outfile; } - } - - if (inCc < 0) - perror (inFile); - cleanup: - close (inFd); - close (outFd); - free (buf); + while (!(flags & FLAG_COUNT) || (G.in_full + G.in_part != count)) { + n = safe_read(ifd, ibuf, ibs); + if (n == 0) + break; + if (n < 0) { + /* "Bad block" */ + if (!(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 ((size_t)n == ibs) + G.in_full++; + else { + G.in_part++; + if (flags & FLAG_SYNC) { + memset(ibuf + n, 0, ibs - n); + n = ibs; + } + } + if (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 (flags & FLAG_FSYNC) { + if (fsync(ofd) < 0) + goto die_outfile; + } + } - printf ("%ld+%d records in\n", (long)(intotal / blockSize), - (intotal % blockSize) != 0); - printf ("%ld+%d records out\n", (long)(outTotal / blockSize), - (outTotal % blockSize) != 0); - exit( TRUE); - usage: + if (ENABLE_FEATURE_DD_IBS_OBS && oc) { + w = full_write_or_warn(obuf, oc, outfile); + if (w < 0) goto out_status; + if (w > 0) G.out_part++; + } + if (close(ifd) < 0) { + die_infile: + bb_simple_perror_msg_and_die(infile); + } - usage( dd_usage); -} + if (close(ofd) < 0) { + die_outfile: + bb_simple_perror_msg_and_die(outfile); + } + exitcode = EXIT_SUCCESS; + out_status: + dd_output_status(0); + return exitcode; +}